为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 人生苦短，我用Python——...

人生苦短，我用Python——Python3基础小记

标签：
Python

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

图片描述

参考教程：
https://coding.imooc.com/lesson/136.html#mid=7114
https://www.w3cschool.cn/youshq/

点击查看更多内容
发表于 2019.07.31 01:08， 共 2029 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
1人点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

Coder_zheng

算法工程师
手记
篇
粉丝
23
获赞与收藏
45

关注作者，订阅最新文章

相关文章推荐

阅读免费教程

感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消