1.Python列表：
里面可以放各种不同类型的数据
用单个数字访问列表–>结果是字符串
用索引来访问列表 --> 结果还是列表
2.列表的加法操作：
3.列表乘以数字N：列表里面的元素被重复N次
4.元组的操作和列表类似
5.在Python中str,list,tuple都被称为序列，操作也很相似，都是有序的，存在序号
6.列表的各种操作
7.集合Set的特点：
(1)无序的，不能用索引来访问
(2)元素不重复
(3)和序列一样，可以判断元素是否包含
(4).(优势):可以按照要求，剔除元素
减号的意思：求两个集合的差集
(5).(优势)&：求两个集合的交集
(6).(优势)|：求两个集合的并集
(7).定义空的集合：
8.字典Dict:集合类型，和set很像，是无序的，不属于序列
Value可用的类型：str,int,float,list,set,dict等
Key可用的类型：不可变的类型，例如元组(tuple)，字符串(str)
9.值类型和引用类型
int，str,tuple为值类型(不可改变)，list,set,dict为引用类型(可变)
10.tuple的多维度访问：
11，非布尔类型参与运算的“短路定理”
12，成员运算符:in,not in,返回布尔类型
特殊情况：字典的成员运算
13.身份运算”is”与关系运算”==”的区别
关系运算符比较的是两个变量的值是否相等，身份运算符比较的是两个变量的身份(内存地址)是否相等
用“id”查看内存地址
测试：
14.对象的三个特征：身份(id),值(value),类型(type)，对应的操作分别为：
is,==,isinstance
15.while 或者while-else算法适合用于递归，遍历或者循环(序列,集合，字典)用for
16.print()里面有个参数，’end=’,表示运行一次print()后用什么结尾，默认情况下,end = \n.
17.切片(比如[0:10])和range都有step(步长)这个参数。
18.换行除了用反斜杠\ ,还可以用小括号( )
19.Package里面_init_.py文件的作用，当这个包被import时，init文件会自动执行。而_all_决定模块的哪些地方被导出。
20.写代码时为了方便，Package里面需要import的库可以在_init_.py中生成，从而避免其他文件烦琐地再次导入。
21.循环import操作很危险，比如在p2.py中写”from p1 import p1”,在p1.py中写”from p2 import p2”，会很麻烦。
22.Python模块的内置变量(前后都加了双下划线)，
__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
25.定义函数时，可以先建一个默认参数，例如 def add(a=1,b=2)
26.可变参数，def demo(*param):
demo(1,2,3),demo(1,2,3,4)都能运行成功
27.运行以下代码，验证*是否有”解包”的作用:
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):
可以自己写写函数验证两者的不同
29.关键字可变参数
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
38.在类的方法名前加，“__”相当于”私有方法”，可以防止被外部调用。
39.继承性:
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遍历
42.闭包
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)
44.Python语言的三元表达式结构，
和C语言的有差别
伪代码：条件为真时返回的结果 if 条件判断 else 条件为假时的返回结果
r = x if x > y else y
45.map,filter,reduce
#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))
随时随地看视频
