Python基础—list、set、dict、函数参数

Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

常量，习惯上用全部大写的变量名表示，但是Python没有任何机制保证该变量不会被修改

除法

不同于其他语言，Python中的除法是精确的，返回的是浮点数，即便两个整数恰好整除，结果也是浮点数

    9 / 3 = 3.0
    10 / 3 = 3.3333333333335

还有种地板除法 // ,使得两个整数的除法仍然是整数

    10 // 3 = 3

list 有序集合，类型可以不同


    classmates = ['michael', 'bob', 'tracy']
    classmates[0]
    len(classmates)
    classmates.append('luseike') # 追加到末尾
    classmates.insert(1, 'jack') # insert 插入到指定位置
    classmates.pop()             # 删除末尾
    classmates.pop(1)            # 删除指定位置的元素
    classmates[1] = 'sara'       # 元素替换，直接赋值
    L = ['apple', 213, True]     # list内的元素有序，类型可以不同

tuple 另一种有序列表，和list很相似，但是tuple一旦初始化就不能被修改

    # 不再有append、insert这样的方法
    classmates = ('michael', 'bob', 'tracy')

tuple在定义的时候就必须被确定下来，定义空的tuple可以写成()，定义一个元素的tuple必须追加，

t = (1)     # 定义的是1这个数，不是tuple
t = (1, )

dict 和 set

dict 是Python的内置字典 key--value

d = {'luseike': 100, 'lemon': 80}

d['luseike']            # 取值  key不存在会报异常
d['adam'] = '85'        # 加值 多次对一个key放入value，后面的值会把前面的值冲掉

if 'luseike' in d:
    pass                # key in dict 判断key是否存在，返回bool

d.get('luseike')        # get(key) 不存在返回None，或者自己指定value
d.get('luseike', -1)

set和dict类似，一组key的集合，但不存储value
set 可以看成数学意义上的无序和无重复元素的集合，因此两个set可以做数学意义上的交集、并集

s = set([1, 2, 3])      # set的传入参数是一个list
s                       # {1, 2, 3}
s.add(4)                # set.add(key)
s.remove(4)             # set.remove(key)


s = set([1, 2, 3, 4])
s2 = set([2, 3, 4, 5])
print(s | s2)           # 并集
print(s & s2)           # 交集

函数的参数

必选参数
默认参数
可变参数
关键字参数
命名关键字参数

def power(x, n = 2):
    total = 1

    while n > 0:
        n = n - 1
        total = total * x

    return total

# `必选参数在前，默认参数在后`

print(power(8))
print(power(5, 3))          

def enroll(name, gender, age = 6, city = 'sh'):
    print("name: ", name)
    print("gender: ", gender)
    print("age: ", age)
    print("city: ",city)

# 有多个默认参数，即可以按照参数顺序依次传值，也可以绑定参数名、不按照顺序传值
enroll('lemon', 'F', 20, 'nj')
enroll('luseike', 'M', city='ah')

默认参数必须指向不变对象

def add_end(L = []):
    L.append('END')
    return L

print(add_end())
print(add_end())
# ['END']
# ['END', 'END']

Python函数在定义的时候，默认参数L就已经被计算出来，存在内存中，它也是一个变量。
每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了

def add_end2(L = None):
    if L is None:
        L = []
    L.append('END')
    return L

print(add_end2())
print(add_end2())

可变参数

可变参数在参数名前有个*，函数内部接收的是一个tuple；如果有一个tuple或list，Python是用在list或tuple前面加*，变成可变参数传递

def mutable_params(*nums):
    total = 0
    for num in nums:
        total += num
    return total

print(mutable_params(1, 2, 3, 4, 5))

add_nums = [6, 7, 8, 9, 10]
print(mutable_params(*add_nums))

关键字参数 **

允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动封装为一个dict

def person(name, age, **other_info):
    print('name:', name, 'age:', age, "otherInfo:",other_info)
person('luseike', 28)                                       # 可以只传入必选参数
person('luseike', 28, nickname = '男神', city = 'ah')     # 传入任意个数的关键字参数


extra = {'city': 'beijing', 'job': 'ios_developer'}
person('laojiang', 27, city = extra['city'], job = extra['job'])
# **extra 表示把extra这个字典的所有key-value用关键字参数传入到**other_info参数
person('laojiang', 27, **extra)

命名关键字参数

关键字参数传入不受限制的key-value，具体传入了啥只有在函数内部检查，如果要限制关键字参数的名字，就可以用命名关键字参数

def person2(name, age, *, city = 'beijing', job):
    print(name, age, city, job)

person2('luseike', 18, city = 'shanghai', job = 'pythonDev')
person2('lucy', 20, job='UI')

命名关键字参数需要一个特殊的分隔符 *， *后面的参数被视为关键字参数
关键字参数必须传入参数名，缺少参数名，Python解释器会理解为是一个位置参数
命名关键字参数具有默认值时，可以不传入
如果有可变参数（带*的参数），可以省略 * 分隔符