python语法精要

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

• 不可变对象 immutable
• 可变对象 mutable

基本要点

• 约定俗成:变量声明应为下划线表示法 user_age
• 强型语言，因此如字符串拼接数字，数字需手动转换为字符串再拼接
• 循环 与 if 要习惯缩进 -列表-list-[]:存多个元素，可增删改查；元组-tuple-():存多个元素，只能查看；字典-dist-{}:存键值对，可增删改查

数据类型

布尔表达式

False 与 True

列表:不变性

• 添加成员

list = []
list.append(10086)

• 删除成员

list = [1]
del list[0]

• 遍历

# for循环
list = []
vals = [1,2,3,4,5]
for val in vals:
	list.append(val**2)
print(list)
print(vals)

# 列表解析
val=[val for val in range(1,11)]

• 切片

 val[startPos:endPos]

api 方法

• sort([reverse=True]) 临时性排序，reverse=True 为可选参数

检查特定值是否包含在列表中

lists = [1,2,3]
1 in lists
4 not in lists

元组:不可变性，用圆括号而不是方括号

Python 将不能修改的值称为 不可变的 ，而不可变的列表被称为 元组

dimensions = (200, 50)
print(dimensions[0])

字典：可变性

是一种动态结构，可随时在其中添加键 — 值对。

• 添加成员

dict = {}
dict['name'] = '千钧壁垒'

• 删除成员

list = {name: '千钧壁垒'}
del list['name']

• 遍历

# for循环
list = {'name': '千钧壁垒', 'age': '18'}
for key, value in list.items():
    txt = "dict value name: " + value + ' dict key name : ' + str(key)
    print(txt)
for value in list.keys():
    txt = "dict key: " + value
    print(txt)
for value in list.values():
    txt = "dict value: " + value
    print(txt)

• set()集合返回对一无二去重

# for循环
list = {'name': '千钧壁垒', 'age': '18', 'win': '18'}
for value in set(list.values()):
    txt = "dict value by set(): " + str(value)
    print(txt)

函数

函数的参数

默认参数

定义默认参数要牢记一点：默认参数必须指向不变对象！因为 Python 函数在定义的时候，默认参数 L 的值就被计算出来了，即[]，因为默认参数 L 也是一个变量，它指向对象[]，每次调用该函数，如果改变了 L 的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

def add_end(L=[]):
L.append('END')
return
# 上述函数，在不传参多次的调用后会达到不好的情况,实际只想在list后面添加一个'END'而已
>>> add_end() # ['END']
>>> add_end() # ['END', 'END']
# 改造
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
# 即时多次不传参也达到相同效果
>>> add_end() # ['END']
>>> add_end() # ['END']

可变参数

可变参数允许你传入 0 个或任意个参数，这些可变参数在函数调用时自动组装为一个 tuple 定义可变参数和定义一个 list 或 tuple 参数相比，仅仅在参数前面加了一个*号。在函数内部，参数 numbers 接收到的是一个 tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括 0 个参数：

# 使用list或tuple参数
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
>>> calc() # 0
>>> calc([1, 2, 3]) # 14
>>> calc([1, 3, 5, 7]) # 84
# 使用可变参数
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
>>> calc() # 0
>>> calc(1, 2, 3) # 14
>>> calc(1, 3, 5, 7) # 84
# *nums表示把nums这个list的所有元素作为可变参数传进去
>>> nums = [1,2,3]
>>> calc(*nums) # 14

关键字参数

关键字参数允许你传入 0 个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个 dict 的一份拷贝，对原传入的关键字参数无影响关键字参数有什么用？它可以扩展函数的功能。比如，在 person 函数里，我们保证能接收到 name 和 age 这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
>>> person('Bob', 35, city='Beijing')
# name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
# name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
# name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键字参数

和关键字参数*kw 不同，命名关键字参数需要一个特殊分隔符，*后面的参数被视为命名关键字参数。如果要限制关键字参数的名字，就可以用命名关键字参数

def person(name, age, *, city, job):
print(name, age, city, job)
>> person('Jack', 24, city='Beijing', job='Engineer')
# Jack 24 Beijing Engineer
>>> person('Jack', 24, 'Beijing', 'Engineer')
# 报错
# File "<stdin>", line 1, in <module>
# TypeError: person() takes 2 positional arguments but 4 were given

命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
>>> person('Jack', 24, job='Engineer')
# Jack 24 Beijing Engineer

参数组合

在 Python 中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这 5 种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
>>> f1(1, 2)
# a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
# a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
# a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

进程与线程

python 底层只要用线程默认 加锁 GIL（Global Interpreter Lock），即使加锁了但也不是安全的，因此要针对性场景使用进程和线程。

• 面向场景
  • 进程：数据密集型计算
  • 线程： 耗时操作，爬虫，IO。。。