里面可以放各种不同类型的数据
用单个数字访问列表–>结果是字符串
用索引来访问列表 --> 结果还是列表
(1)无序的，不能用索引来访问
(2)元素不重复
(3)和序列一样，可以判断元素是否包含
(4).(优势):可以按照要求，剔除元素
减号的意思：求两个集合的差集
(5).(优势)&：求两个集合的交集
(6).(优势)|：求两个集合的并集
(7).定义空的集合：
Value可用的类型：str,int,float,list,set,dict等
Key可用的类型：不可变的类型，例如元组(tuple)，字符串(str)
int，str,tuple为值类型(不可改变)，list,set,dict为引用类型(可变)
10.tuple的多维度访问： 11，非布尔类型参与运算的“短路定理” 12，成员运算符:in,not in,返回布尔类型特殊情况：字典的成员运算
关系运算符比较的是两个变量的值是否相等，身份运算符比较的是两个变量的身份(内存地址)是否相等
用“id”查看内存地址
测试：
__package__,__name__,__doc__,__file__23.设置Python最大递归次数，例如最多递归666次
import sys sys.setrecursionlimit(666)24.当Python函数的返回值return 有多个返回值时
return value1 value2 ,其实返回了一个元组(value1,value2) ,此时接收return的返回结果，可以用一个元组类型的变量接收，也可以用多个变量接收(序列解包)，就像a,b,c = 1,2,3 ;
a,b,c = [1,2,3];a=b=c=1
def demo(*param): print(param) print(type(param)) a = (1,2,3,4,5,6) demo(*a) demo(a)28.必须参数+默认参数+可变参数
def demo(param1,param2 = 2,*param):
def demo(param1,*param,param2 = 2):
可以自己写写函数验证两者的不同
def city_temp(**param): for key in param: print (key) city_temp(bj = '32c',xm = '23c',sh = '31c')
def city_temp(**param): for key,value in param: print (key,':',value) city_temp(bj = '32c',xm = '23c',sh = '31c')
def city_temp(**param): for key,value in param.items(): print (key,':',value) city_temp(bj = '32c',xm = '23c',sh = '31c')
def city_temp(**param):
for key,value in param.items():
print (key,':',value)
a = {'bj':'32c','sh':'31c'}
city_temp(**a)
#可变参数和关键字可变参数甚至可以传入空值 可变参数和关键字可变参数列表通常使用for循环来遍历。 def squsum(*param): sum = 0 for i in param: sum += i * i print(sum) squsum(1,2,3)
def squsum(*param): sum = 0 for i in param: sum += i * i print(sum) squsum(*[1,2,3]) squsum(*(1,2,3))
效果和上面一样
30.对于函数中，for循环外部可以引用for循环内部定义的变量，这点和C，Java不一样。 31.作用域链c = 1 def func1(): c = 2 def func2(): c = 3 print(c) func2() func1()
c = 1 def func1(): c = 2 def func2(): # c = 3 print(c) func2() func1()
c = 1 def func1(): #c = 2 def func2(): # c = 3 print(c) func2() func1()32.通过Global定义全局变量
def demo(): global c c = 2 demo() print(c)33.Python类的构造函数:
def __init__(self):
#注意Python的构造函数不能返回一个字符串
class Student():
name = ''
age = 0
def __init__(self,name,age):
#构造函数
#初始化对象的属性
name = name
age = age
def learn_programming(self):
pass
#类实例化时，
student1 = Student('James',18)
#不能 ：student1 = Student()，建立一个对象没有声明构造函数中的name,age参数时会报错
34.类变量只和类相关，实例变量只和对象相关
class Student():
name = 'Bob'
age = 0
def __init__(self,name,age):
#定义实例变量
self.name = name
self.age = age
def learn_programming(self):
pass
student1 = Student('Tim',19)
student2 = Student('Allen',20)
print (student1.name) #打印实例变量
print (student2.name) #打印实例变量
print (Student.name) #打印类变量
对比一下：
class Student():
name = 'Bob'
age = 0
def __init__(self,name,age):
#定义实例变量
name = name
age = age
def learn_programming(self):
pass
student1 = Student('Tim',19)
student2 = Student('Allen',20)
print (student1.name) #打印实例变量
print (student2.name) #打印实例变量
print (Student.name) #打印类变量
35.在函数中改变类变量用: self.__class __.类变量名
class Student():
name = 'Bob'
age = 0
sum = 0
def __init__(self,name,age):
#定义实例变量
self.name = name
self.age = age
self.__class__.sum += 1
print ('当前班级学生总数为: ' + str(self.__class__.sum))
def learn_programming(self):
pass
36.类方法：用来操作类变量
定义类方法：方法名前有装饰器@
比如：
@classmethod
def plus_sum(cls):
pass
@classmethod
def plus_sum(self):
pass
两个都是类方法，只是第一个参数名,为了防止误导，不再用’self’，而是用cls
类方法只和类本身有关，和实例对象无关。
class Student():
name = 'Bob'
age = 0
sum = 0
def __init__(self,name,age):
#定义实例变量
self.name = name
self.age = age
print ('当前班级学生总数为: ' + str(self.__class__.sum))
def learn_programming(self):
pass
@classmethod
def plus_sum(cls):
cls.sum += 1
print(cls.sum)
student1 = Student('Tim',19)
Student.plus_sum() #给类的sum 加1
student2 = Student('Allen',20)
Student.plus_sum() #给类的sum 加1
print (student1.name) #打印实例变量
print (student2.name) #打印实例变量
print (Student.name) #打印类变量
37.静态方法：实例变量和类都可以调用，静态方法的内部也可以访问类变量
静态方法和类方法里面都不能访问实例变量，例如self.name
class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
class Student(Human):
def learn_programming(self):
print ("I am a student,I use Python")
print (Student.sum)
#下面四个运行会报错
#student1 = Student()
#print (student1.sum)
#print (student1.name)
#print (student1.age)
class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
class Student(Human):
def learn_programming(self):
print ("I am a student,I use Python")
print (Student.sum)
student1 = Student('Oliver',24)
print (student1.sum)
print (student1.name)
print (student1.age)
student1.get_name()
Demo:子类调用父类的构造函数
class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
class Student(Human):
def __init__(self,school,name,age):
self.school = school
Human.__init__(self,name,age)
#子类调用父类的构造函数,父类的实例变量也会得到初始化
#少了self会报错
def learn_programming(self):
print ("I am a student,I use Python")
student1 = Student('CMU','Oliver',24)
print (student1.school)
print (student1.name)
print (student1.age)
*Python允许一个子类继承多个父类。
40.子类调用父类的方法：super关键字class Human():
sum = 0
def __init__(self,name,age):
self.name = name
self.age = age
def get_name(self):
print(self.name)
class Student(Human):
def __init__(self,school,name,age):
self.school = school
#Human.__init__(self,name,age)
super(Student,self).__init__(name,age)
def learn_programming(self):
print ("I am a student,I use Python")
student1 = Student('CMU','Oliver',24)
print (student1.school)
print (student1.name)
print (student1.age)
41.Python的枚举类：
普通类的局限性：1.可变，2.没有防止不同的key出现重复的值
枚举的基本操作:
1.通过value获取Enum的值
2.通过name获取Enum的标签名
3.可以用for-in遍历
def curve_pre(): def curve(): pass return curve f = curve_pre() f() #在函数外面调用curve()
def curve_pre(): a = 25 def curve(x): return a*x*x return curve a = 10 f = curve_pre() print(f(2))
运行结果为100而不是40
闭包 = 函数 + 环境变量(比如curve外的a)
Demo1:
origin = 0 def go(step): new_pos = origin + step origin = new_pos return new_pos print(go(2)) print(go(3)) print(go(4))
Demo2:
origin = 0 def go(step): global origin new_pos = origin + step origin = new_pos return new_pos print(go(2)) print(go(3)) print(go(4))
原因 ： 没有Global关键字，origin就会被系统认为是局部变量
闭包也会遇到同样的问题：
Demo3:
origin = 0 def factory(pos): def go(step): new_pos = pos + step pos = new_pos return new_pos return go tourist = factory(origin) print(tourist(2)) print(tourist(3)) print(tourist(4))
Demo4:
origin = 0 def factory(pos): def go(step): nonlocal pos new_pos = pos + step pos = new_pos return new_pos return go tourist = factory(origin) print(tourist(2)) print(tourist(3)) print(tourist(4))所以一共有两种解决办法，一种是Global，一种是nonlocal
Demo5:
origin = 0 def factory(pos): def go(step): nonlocal pos new_pos = pos + step pos = new_pos return new_pos return go tourist = factory(origin) print(tourist(2)) print(origin) print(tourist(3)) print(origin) print(tourist(4)) print(origin)
闭包的优势:所有操作都发生在函数内部，全局变量没有被改变。
43.lambda表达式：调用方式： 赋值给一个变量
f = lambda x,y: x + y
f(1,2)
和C语言的有差别
伪代码：条件为真时返回的结果 if 条件判断 else 条件为假时的返回结果
r = x if x > y else y
#map的参数结构： #map(function,list或集合),返回一个map对象，可以用list()转换成列表 #map结合lambda表达式，lambda表达式也是一种函数，可以把lambda表达式作为map的function参数 # Demo:求列表里面每个元素的平方 list_x = [1,2,3,4,5,6,7,8] list_y = [1,2,3,4,5,6,7,8] def square(x): return x * x #method1 r = map(square,list_x) print(list(r)) #method2 r = map(lambda x:x*x,list_x) print(list(r)) #map里面处理两个变量 r = map(lambda x,y: x*x + y,list_x,list_y) print(list(r))
#list_x和list_y数值的个数不相同 list_x = [1,2,3,4,5,6,7,8] list_y = [1,2,3,4,5,6] r = map(lambda x,y:x*x + y,list_x,list_y) print(list(r))
#reduce的计算过程演示 from functools import reduce #过程:连续计算，连续调用lambda list_x = [1,2,3,4,5,6,7,8] r = reduce(lambda x,y:x+y, list_x) print(r) #运算过程： #(((((((1+2)+3)+4)+5)+6)+7)+8)
#reduce指定初始值 from functools import reduce list_x = ['1','2','3','4','5','6','7','8'] r = reduce(lambda x,y:x+y,list_x,'aaa') print(r)
#filter实例,用法和map很像 #filter要求function参数，例如lambda表达式，可以返回"真，假"，不一定得是True和False,也可以是0和1 list_x = [1,0,1,0,0,1] r = filter(lambda x:x,list_x) print(list(r)) r = filter(lambda x:True if x==1 else False,list_x) print(list(r))
参考教程：
https://coding.imooc.com/lesson/136.html#mid=7114
https://www.w3cschool.cn/youshq/
