解构赋值
a, b, c = [1, 2, 3] # 列表解构
print(a, b, c)
a, b, c = (1, 2, 3,) # 元组解构
print(a, b, c)
a, b, c = {1, 2, 3} # 集合解构
print(a, b, c)
a, b, c = range(1, 4) # 范围解构
print(a, b, c)
a, b, c = "hel" # 字符串解构
print(a, b, c)
a, b = {"name": "lisi", "age": 34} # 字典解构
print(a, b)
将可迭代对象依次赋值给左边变量
函数定义
def my_sum(num1, num2):
'''
calculate two num sum
:param num1:
:param num2:
:return:
'''
return num1 + num2
print(my_sum(2, 5)) # 位置对应
print(my_sum(num2=5, num1=2)) # 参数名称对应
print(my_sum(3, num2=8)) # 混合
使用def关键字声明函数，3引号声明函数文档注释，没有return语句会返回None，多个返回值会包装成元组。实参和形参必须一一对应，不能多也不能少。位置对应必须在名称对应之前。
默认参数
def my_sum(num1, num2, num3=0):
'''
calculate three num sum
:param num1:
:param num2:
:param num3:
:return:
'''
return num1 + num2 + num3
print(my_sum(6, 5))
print(my_sum(6, 5, 2))
默认参数在声明函数时定义，传参使用参数值，不传使用默认值。默认参数必须为不可变对象。
可变参数
def my_sum(*nums):
sum = 0
for num in nums:
sum += num
return sum
print(my_sum(1, 2, 3, 4, 6)) # 可变参数
print(my_sum(*[1, 2, 3, 4, 5])) # 解构赋值
python会将多个参数包装成元组传递给函数。
关键字参数
def person(name, age, **kwargs):
return {"name": name, "age": age, **kwargs}
print(person("lisi", 23, city="shanghai", job="java"))
print(person(**{"name": "lisi", "age": 23, "city": "shanghai", "job": "java"})) # 解构赋值
python会将多个关键字参数包装成字典传递给函数。
局部变量和全局变量
NAME = "lisi" # 全局变量
AGE = 23 # 全局变量
def change_name():
global NAME # 关联全局变量
NAME = "lisi2" # 修改全局变量
AGE = 34 # 局部变量
print(NAME, AGE)
change_name()
print(NAME, AGE)
使用global修改全局变量，先找局部变量，找不到再找全局变量。
NAME = "lisi" # 全局变量
def change_name():
NAME = "xioaming"
def change_name2():
nonlocal NAME #关联上一级作用域变量
NAME = "xioali" # 修改
print(NAME)
change_name2()
print(NAME)
change_name()
print(NAME)
使用nonlocal修改上一级作用域变量
递归函数
def my_sum(*nums):
if len(nums) == 0:
return 0
return my_sum(*nums[0:-1]) + nums[-1]
print(my_sum(1, 2, 3, 6))
print(my_sum(1))
print(my_sum())
递归就是直接或间接的调用自己。
闭包
def create_counter(num=0):
def inc():
nonlocal num
num += 1
return num
return inc
counter = create_counter()
print(counter()) # 1
print(counter()) # 2
counter = create_counter(5)
print(counter()) # 6
print(counter()) # 7
python中，只有函数内部或函数内部的子函数才可以读取或修改局部变量，闭包就是可以读取其他函数内部变量的函数，简单理解为函数内部的函数，它是将函数内部和函数外部连接的桥梁。
lambda函数
my_sum = lambda x, y: x + y
print(my_sum(3, 4))
python的lambda函数的函数体只能是表达式，不能是多条语句。
内置函数
print(abs(-12)) # 求绝对值
print(min(3, 5, 7, -3, 4)) # 最小值
print(max(4, 5, 6, 7)) # 最大值
print(sum([1, 2, 3], 0)) # 求和
print(pow(3, 2)) # 求幂次方
print(round(3.4568, 2)) # 四舍五入
print(divmod(9, 2)) # 求商和余数
print(int("123")) # 转为int类型
print(float("123")) # 转为float类型
print(bool("1")) # 转为bool类型 0或空为False
print(bin(123)) # 转为2进制字符串
print(oct(123)) # 转为8进制字符串
print(hex(123)) # 转为16进制字符串
print(ord("A")) # 获取对应的10进制整数
print(chr(65)) # 获取对应的字符
print(eval('2**3')) # 执行python语句
exec('print(2**3)') # 执行python语句
f = open("test.txt", "r") # 打开文件
print(f.readlines())
print(str([1, 2, 3])) # 转为字符串形式
class Person():
pass
p = Person()
setattr(p, "len", 4) # 设置属性值
print(getattr(p, "len")) # 获取属性值
print(hasattr(p, "len")) # 是否包含属性
delattr(p, "len") # 删除属性
print(all([1, 2, 3, 0])) # 可迭代对象是否全部为True
print(any([1, 2, 3, 0])) # 可迭代对象是否有一个为True
print(dir()) # 获取当前模块的属性列表
it = iter([1, 2, 3]) # 获取列表的迭代器对象
while True:
try:
print(next(it)) # 获取迭代器的下一个对象，没有抛出异常
except StopIteration:
break
sli = slice(0, 2, 1) # 创建切片对象
print([1, 2, 3, 4, 5][sli])
print(id("lisi")) # 获取对象的内存地址
print(sorted([1, 3, 6, 4])) # 对可迭代对象排序
print(list(reversed([1, 3, 6, 4]))) # 翻转可迭代对象
print(ascii([1, 2, 3])) # 获取对象的字符串表示
for (i, v) in enumerate(["lisi", "zhangsan"]): # 获取可迭代对象的索引序列，包含索引和数据
print(i, v)
print(isinstance("", (str, list))) # 对象是否为类的实例
print(issubclass(bool, int)) # 是否为父类
class Father:
def sing(self):
print("father sing")
class Child(Father):
def sing(self):
super().sing() # 调用父类方法
print("child sing")
print(Child().sing())
print(bytearray("lisi", encoding="utf-8")) # 创建字节数组
print(bytes("lisi", encoding="utf-8")) # 创建不可变字节数组
print(dict(name="lisi", age=23)) # 创建一个字典
print(tuple([1, 2, 3])) # 创建元组
print(list((1, 2, 3,))) # 创建列表
print(set([1, 2, 3])) # 创建集合
print(frozenset([1, 2, 3])) # 创建不可变集合
print(range(5)) # 创建范围对象
print(list(filter(lambda x: len(x) >= 4, ["java", "go", "python"]))) # 过滤可迭代对象
print("abc") # 打印输出函数
print(callable(Child)) # 是否是可调用的
print("name:{name},age:{age}".format(name="lisi", age=23)) # 字符串格式化
print(len("hello")) # 获取对象长度
print(type("")) # 获取对象类型
print(vars(p)) # 获取对象的属性
print(hash("abxc")) # 获取对象的哈希值
print(list(map(lambda x: x ** 2, [1, 2, 3]))) # 映射
print(list(zip([1, 2, 3], [4, 5, 6]))) # 将可迭代对象打包成元组
print(help('str')) # 查看函数或模块的详细信息
print(input("please input num: ")) # 接受标准输入