1、列表推导式
y=[x for x in range(1,10)]
print(y) #返回值[1,2,3,4,5,6,7,8,9]
y=[(row,col) for row in range(1,10) for col in range(1,10)]
print(y)
#返回值[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]
2、字典推导式
my_test="i love you i want kill you"
dict_count={c:my_test.count(c) for c in my_test}
print(dict_count)
#返回值{'v': 1, 'a': 1, 'k': 1, 'e': 1, 'l': 3, 'i': 3, 'o': 3, 'y': 2, 'w': 1, 'n': 1, 'u': 2, ' ': 6, 't': 1}
3、集合推导式:只有key，没有value,不能重复
y={x for x in range(1,100) if x%9==0}
print(y)
#返回值{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}
4、生成器推导式(生成元祖)，生成器只能生成一次
y=(x for x in range(1,10))
print(y) #<generator object <genexpr> at 0x000001D5541D7A98> 返回一个迭代器
for z in y:
print(z,end=",")
print(tuple(y))
#返回值 1,2,3,4,5,6,7,8,9,()
5、行参和实参
def fac(a,b): #a和b称为行参
return a+b
fac(1,2) #调用函数的参数称为实参
6、文档的字符串(函数注释)
''' ''' #三个单引号可以进行多行注释
7、函数返回值: return
a、如果函数主体包括return语句,则结束函数执行并返回值
b、如果函数体中不包含return语句,则返回None
c、要返回多个返回值,使用列表,元祖,字典,集合将多个值保存起来
8、测试函数也是对象.
def test01():
print("test01")
test01()
c=test01
c()
print(id(test01))
print(id(c))
print(type(c))
#返回值
test01
test01
2539107983568
2539107983568
<class 'function'>
9、全局变量和局部变量
全局变量:1、在函数和类的定义之外声明的变量，作用域为定义的模块，从定义位置开始直到模块结束
2、全局变量降低了函数的通用性和可读性,应尽量避免全局变量的使用
3、全局变量一般做常量使用
4、函数内需要改变全局变量的值，需要global声明一下
局部变量:1、在函数体(包含形式参数)声明的变量
2、局部变量的引用比全局变量的引用快，优先引用局部变量
3、如果全局变量和局部变量同名，优先隐藏全局变量，只使用同名的局部变量.
10、传递不可变变量
a、传递参数是不可变对象(例如 int 、float、字符串、元祖和布尔值)。实际传递还是对象的传递,由于不可变变量不可修改，在赋值的时候，会新建对象.
b、当传递不可变变量的时候,不可变变量包含的子变量是可变的，如果方法内修改了子变量里的可变变量，源变量也会发生变化
a=(10,20,[30,40])
print("a:",id(a))
def test01(m):
print("m:",id(m)) #m和a指向同一个地址，元祖不可变，但列表可变，m指向的地址中,由于列表值的变化，但地址不变，所以打印a的时候，值也会变化
m[2][0]=2000
print(0m)
print("m:",id(m))
test01(a)
print(a)
#返回值
a: 2033318930832
m: 2033318930832
(10, 20, [2000, 40])
m: 2033318930832
(10, 20, [2000, 40])
11、lambda表达式和匿名函数
lambda表达式可以用来声明匿名函数,lambda函数实际上生成一个新的函数对象，只允许一个表达式,不能包含复杂表达式。
gnt=[lambda x:x*2,lambda y:y*2,lambda z:z*2]
print(gnt[0](9),gnt[1](10),gnt[2](30))
#返回值18 20 60,其中[]为索引位置
12、eval()函数:将字符串str当成有效的表达式来求值并返回计算结果.
a=10
b=20
c=eval("a+b")
print(c) #返回值30
d=dict(a=100,b=200)
e=eval("a+b")
print(e) #返回值30
f=eval("a+b",d) #使用d中的a和b
print (f)#返回值300
13、递归函数，函数的反复调用，但是需要参数来控制退出。
def fac01(n):
print("fac01",n)
if n==0:
print("over")
fac02()
print("********")
else: fac01(n-1)
def fac02():
print("fac02")
fac01(4)
#返回值
fac01 4
fac01 3
fac01 2
fac01 1
fac01 0
over
fac02
********
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————
14、嵌套函数:封装，数据隐藏，外部无法访问嵌套函数.
15、_call_ 调用方法函数。
16、python中方法不能重载，存在重名的方法将被覆盖，调用的时候调用最后一次的方法
class Person:
def work(self):
print("努力上班")
def play_game(s):
print("{0}在玩游戏".format(s))
def work2(s):
print("好好上班")
Person.play=play_game #将函数play_game的地址传给Person.play
p=Person() #类的对象赋给p
p.work() #调用类的work方法
p.play() #解释器调用方法相当于 Person.play(p) 相当于把def play_game()加入class Person
Person.work=work2 #python中方法没有重载，当有重名方法的时候，最后一个方法将覆盖前面的方法
p.work()
#返回值:
##### 努力上班
##### <__main__.Person object at 0x0000024424CAF828>在玩游戏
##### 好好上班
总结步骤：第一步：将新需要加入的函数地址赋值给类对象 Person.play=play_game
第二步：将类对象初始化 p=Person()
第三步，调用类对象被赋值的地址 p.play()
17、私有属性和私有方法
1、通过规定俩个下划线开头的属性定义为私有，其他的都是公开的
2、类内部时可以访问私有属性
3、类的外部是不能直接访问私有属性，但可以通过_类名__私有属性或者方法