python输出与3无关的数_人生苦短，我用Python——Python3基础小记

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))