Python总结

一、注释

单行注释		#
多行注释     """ """		
1
2

二、运算符
1，算术运算符：

    +	加法运算符
	-	减法运算符
	*	乘法运算符
	/	除法运算符
	%	求模（余）运算符
	//	整除运算（地板除法）
	**	幂次方
1
2
3
4
5
6
7

2，关系（比较）运算符

    >
	<
	>=
	<=
	==
	!=
1
2
3
4
5
6

3，逻辑运算符

    与（并且） and
	或（或者） or
	非（取反） not
1
2
3

4，所属运算符

in		# 变量 in 容器
not in
1
2

5，赋值运算符

=
	+=		# a += 10 <==> a =  a + 10
	-=
	*=
	/=
	//=
	%=
	**=
1
2
3
4
5
6
7
8

6，三目运算符：

表达式? 变量1 : 变量2
	# 其他编程语言中的三目运算符
	int a = 10 <  8 ? 20 : 40;	
	# python中
	变量1 if 表达式 else 变量2
1
2
3
4
5

三、选择结构

单分支
    if 条件:
		# 如果条件成立，则执行缩进后的代码 
双分支
	  if 条件:
		# 如果条件成立，则执行if中的代码
	else:
		# 如果条件不成立，则执行这儿（else）的代码
多（三）分支
	if 条件1:
		# 如果条件1成立，则执行if中的代码
	elif 条件2:
		# 如果条件1成立，则执行这儿的代码
	elif 条件3:
		# 如果条件1成立，则执行这儿的代码
	……
	[else:
		# 剩余情况，执行这儿的代码
		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

四，循环结构

while循环
	
	while 条件:
		# 执行循环体
for循环
	python的for循环，本质是一种for in结构的foreach循环，也就是是一种迭代结构
	python提供的for循环，想法就是用来迭代可迭代对象（Iterable）的数据的遍历的。

for 临时变量 in Iterable:
	# 每一次迭代的结果会保存在这个临时变量中
	print(临时变量)
1
2
3
4
5
6
7
8
9
10
11

五、常见容器

列表（list）：	
	列表的定义：
		有两种方式：通过弱数据类型语言的特点完成
			ls = [12,34,45,88,99]
		第二种，就是调用一个全局函数
			list()
			list([元素1, 元素2, ……, 元素n])
		
set：
	一般集合都是使用hash表实现，
	无序且不重复！！！！
定义集合
	s = {值1, 值2,…… 值n}	# set定义是，不能为空，为空表示一个空字典
	
	ssss = set([1,2,3,4,45,5]) # 使用set函数完成list转换为set
	同样的道理
	list({1,3,2,43,44,4,5})		# 将set转换为list

元组（tuple）
	固定的值，不可变数据类型，类似于java、C这些中枚举类型

字典（dict）：
	注意，python中的字段也是一个{}形式，只是里面的元素，不是一个个的值
	而是一对键值对	
	d = {"name": "张三", "age": 34, "nickname": "法外狂徒"}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

六、函数

什么是函数：
	就是具有名称的一个功能代码的集合
python如何定义函数：
		 函数名称的命名规范，遵循变量命名规范！！！！
	def 函数名称([参数列表]):  # define function 定义函数
		函数体
		如果有返回值，则使用return关键字返回函数结果
		return 返回值
调用函数：
	函数名称([实参列表]
	
局部变量（本地变量）：
	定义在函数内部的变量叫做局部变量，作用域是当前函数

全局变量：
	直接定义模块（py文件）中的变量，叫做全局变量

return关键字：
	值存在于函数内部，函数如果访问到return关键字，则立刻返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

递归（recursion）：
本质是一种解决问题的方案。

七、切片：
切片是python提供，用来切割字符串的一种方式
切片不仅仅是针对字符串，有序序列（list、tuple、字符串）

字符串[下标]

字符串[start:end]		# 切割字符串，注意：[start, end)，默认步长是1
字符串[start:end:step]		# 切片操作时，指定步长

注意：注意，切片不会下标越界；
默认步长是1，可以指定，如果指定为正数，则表示从左向右切
	但是如果指定为负数，表示从右向左切
如：s[::-1]，表示翻转字符串的顺序，类似于s.reverse()
1
2
3
4
5
6
7
8
9

八、内置模块

 - math    - random      - os 
 - sys      - datetime   - date 
 - calendar  - hashlib 	 - hmac
   等等 
1
2
3
4

九、对象序列化
对象序列化：
对象：抽象概念
如果我们要传输对象，就需要将对象由逻辑概念转换为真实存在的数据（字符串、字节）
对象反序列化：
将物理状态的数据转换为逻辑状态

python提供了两个对象序列化和反序列化的模块
pickle：对象 <> 字节数据
json： 对象 <> json

pickle：
pickle.dump(obj, file)：对象持久化（先序列化，在持久化）
pickle.load(file)：反持久化，将数据从磁盘重新读成对象

picke.dumps(obj)：对象序列化
pickle.loads(bytes)：反序列化对象
1
2

json模块：
ison.dump(obj, file)：对象持久化（先序列化，在持久化）
ison.load(file)：反持久化，将数据从磁盘重新读成对象

ison.dumps(obj)：对象序列化
ison.loads(bytes)：反序列化对象
1
2

十、面向对象
类（class）：对一些相似特性的事物的抽象总结，抽象概念。
对象（object）：一类事物的一个具体案例，实实在在的案例（实例）
定义类：
python定义类使用，class关键定义。

class 类名称:	# 类名称的命名规范遵循大驼峰法
class 类名称(父类):
class 类名称(Object):
1
2
3

面向对象的三大特征：
封装：

在面向对象中：
	1、所有的面向对象相关功能，封装在一个类里面
	2、在一个类中，将属性私有化，外界不允许访问属性，
		一般通过提供公开的方法（getter、setter）来访问和设置

封装的本质：就是对类中属性的数据的保护，不允许外界非法访问
	只允许，通过提供的公开的方式来访问数据！！！

将属性私有化之后，如何在外界访问该属性？

1、直接提供get和set方法
2、将get和set再次包装一把，之后使用类似于属性的方法私有的属性
3、使用@property的装饰器完成封装
1
2
3
4
5
6
7
8
9
10
11
12
13

class User(object):

    def __init__(self):
        # python中，在属性名称或者方法名称前面加上__,表示私有化该属性或者方法
        # 此时在该类的外部，将无法访问到私有的属性和方法
        self.__name = "刘建宏"
        self.__age = 16
        self.__gender = "男"
        self.__email = "110@qq.com"
        self.__tel_phone = "110"

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age

    def say(self):
        print("我叫{}，我说了句话".format(self.__name))
        print("这句话，我不爱听，所以我难过")
        self.__cry()

    def __cry(self):
        """该方法私有，私有的方法，就是在类内部使用的"""
        print("我哭了，我很难过")


if __name__ == '__main__':
    u1 = User()
    # u1.say()
    # print(u1.__name)
    # u1.name = "刘帅哥"
    # print(u1.name)

    # 通过getter、setter访问和设置属性
    print(u1.get_name())
    u1.set_name("张秋硕")
    u1.set_age(19)
    print(u1.get_name())
    print(u1.get_age())
    # Python的封装并不算特别完美
    # print(u1._User__age)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

继承

后代会继承先代的特征或者特征
子类会继承父类的一些方法（父类允许继承的方法）
1
2

class RichMan(object):

    def __init__(self):
        # 私有属性无法继承
        self.__name = "阿爸"
        self.money = 40000000
        self.company = "alibaba"

    def say(self):
        print("哎，生意不好做啊，我对钱不感兴趣，我最后悔的事，就是创建了公司")

    def __tell(self):
        print("这些是我的悄悄话，我不想任何人知道")


# python允许多继承
class Son(RichMan, object):
    pass


if __name__ == '__main__':
    s = Son()
    print(s.money)
    print(s.company)
    # print(s.__name)
    s.say()
    # s.__tell()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

多态

面向对象中，多态：父类引用指向子类实例的现象！

ArrayList al = new ArrayList();		// 创建一个ArrayList对象
List list = new ArrayList();		// 父类引用指向子类实例的现象！！！
1
2
3
4

十一、python高级
生成器（generator）：
列表推导式，
优点：可以通过一段代码，生成我们想要的列表数据，非常强大
缺点：如果数据量多的时候，直接生成数据，内存太大
因此python提供了新的列表生成方式，这个方式就是列表生成器

ls = []


def get_prime():
    for i in range(2, 101):
        flag = is_prime(i)
        if flag:
            # ls.append(i)
            yield i         # yield虽然看起来和return很像，但是注意，不一样


def is_prime(num):
    for j in range(2, num):
        if num % j == 0:
            # 不可能是质数
            return False
    return True

# res = get_prime()
# print(ls)
# print(res)
# print(next(res))
# print(next(res))

# for i in res:
#     print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

生成器的遍历：
使用for循环可以遍历生成器
for 变量 in generator:
print(该变量每一次循环就是一个生成器的值)
第二种列表生成器的写法：
如果列表推导式过于复杂，想使用这种方式[表达式]非常困难
针对于这种情况，一般使用函数来完成该列表的初始化

将函数转换为列表生成，使用关键字yield
注意：当函数转换为列表生成器时，函数的执行顺序
1
2

迭代器（Iterator）：
可以通过next函数调用，并且返回下一个值的对象
可迭代对象（Iterable）：
能够被循环调用，返回下一个值的，可迭代对象
字符串、列表、元组、字典、集合
闭包（closure）：
能够方法函数内部的变量的函数，被称为闭包

闭包：导致函数常驻内存，无法被释放！！！！
局部变量全局化：避免了全局污染！！！

装饰器：
装饰者设计模式的体现，当我们对原有功能不能满足的时候，
我们可以通过装饰原有代码，来实现代码增强

	python提供的装饰器（Decorator），就是强化和装饰原有函数功能，
	将函数功能加强的一种语法

    python的装饰器，它运行流程
1
2
3
4

十二、异常处理
非正常的一种软件奔溃的现象，称为异常
异常进行处理，本质是一种软件的容错性

抓捕异常：

 	判断代码可能会出现异常
     	try:	
	可能出异常的代码	
     	except:
	可能出现的异常
1
2
3
4
5

def main():
	y_o_n = input("是否退出程序(y/n)?")
	while y_o_n != "y":
		print("请输入一下信息，用空格分开")
		input_str = input("性别 体重(kg) 身高(cm) 年龄： ")
		str_list = input_str.split(" ")
		try:
			gender = str_list[0]
			weight = float(str_list[1])
			height = float(str_list[2])
			age = int(str_list[3])

			if gender == "男":
				bmr = (13.7*weight)+(5.0*height)-(6.8*age)+66
			elif gender == "女":
				bmr = (9.6*weight)+(1.8*height)-(4.7*age)+655
			else:
				bmr= -1

			if bmr!= -1:
				print("你的性别：{}，体重：{}公斤，身高：{}厘米，年龄：{}岁".format(gender,weight,height,age))
				print("你的基础代谢率：{}大卡".format(bmr))
			else:
				print("暂时不支持该性别")
		except ValueError:
			print("请输入正确信息")
		except IndexError:
			print("输入信息量过少！")
		except:
			print("程序异常！")
			
		print()
		y_o_n=input("是否退出程序(y/n)?")


if __name__ == '__main__':
	main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38