代码收藏家 Python总结
一、注释
单行注释 #
多行注释 """ """
二、运算符
1，算术运算符：
+ 加法运算符
- 减法运算符
* 乘法运算符
/ 除法运算符
% 求模（余）运算符
// 整除运算（地板除法）
** 幂次方
2，关系（比较）运算符
>
<
>=
<=
==
!=
3，逻辑运算符
与（并且） and
或（或者） or
非（取反） not
4，所属运算符
in # 变量 in 容器
not in
5，赋值运算符
=
+= # a += 10 <==> a = a + 10
-=
*=
/=
//=
%=
**=
6，三目运算符：
表达式? 变量1 : 变量2
# 其他编程语言中的三目运算符
int a = 10 < 8 ? 20 : 40;
# python中
变量1 if 表达式 else 变量2
三、选择结构
单分支
if 条件:
# 如果条件成立，则执行缩进后的代码
双分支
if 条件:
# 如果条件成立，则执行if中的代码
else:
# 如果条件不成立，则执行这儿（else）的代码
多（三）分支
if 条件1:
# 如果条件1成立，则执行if中的代码
elif 条件2:
# 如果条件1成立，则执行这儿的代码
elif 条件3:
# 如果条件1成立，则执行这儿的代码
……
[else:
# 剩余情况，执行这儿的代码
四，循环结构
while循环
while 条件:
# 执行循环体
for循环
python的for循环，本质是一种for in结构的foreach循环，也就是是一种迭代结构
python提供的for循环，想法就是用来迭代可迭代对象（Iterable）的数据的遍历的。
for 临时变量 in Iterable:
# 每一次迭代的结果会保存在这个临时变量中
print(临时变量)
五、常见容器
列表（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": "法外狂徒"}
六、函数
什么是函数：
就是具有名称的一个功能代码的集合
python如何定义函数：
函数名称的命名规范，遵循变量命名规范！！！！
def 函数名称([参数列表]): # define function 定义函数
函数体
如果有返回值，则使用return关键字返回函数结果
return 返回值
调用函数：
函数名称([实参列表]
局部变量（本地变量）：
定义在函数内部的变量叫做局部变量，作用域是当前函数
全局变量：
直接定义模块（py文件）中的变量，叫做全局变量
return关键字：
值存在于函数内部，函数如果访问到return关键字，则立刻返回
递归（recursion）：
本质是一种解决问题的方案。
七、切片：
切片是python提供，用来切割字符串的一种方式
切片不仅仅是针对字符串，有序序列（list、tuple、字符串）
字符串[下标]
字符串[start:end] # 切割字符串，注意：[start, end)，默认步长是1
字符串[start:end:step] # 切片操作时，指定步长
注意：注意，切片不会下标越界；
默认步长是1，可以指定，如果指定为正数，则表示从左向右切
但是如果指定为负数，表示从右向左切
如：s[::-1]，表示翻转字符串的顺序，类似于s.reverse()
八、内置模块
- math - random - os
- sys - datetime - date
- calendar - hashlib - hmac
等等
九、对象序列化
对象序列化：
对象：抽象概念
如果我们要传输对象，就需要将对象由逻辑概念转换为真实存在的数据（字符串、字节）
对象反序列化：
将物理状态的数据转换为逻辑状态
python提供了两个对象序列化和反序列化的模块
pickle：对象 <> 字节数据
json： 对象 <> json
pickle：
pickle.dump(obj, file)：对象持久化（先序列化，在持久化）
pickle.load(file)：反持久化，将数据从磁盘重新读成对象
picke.dumps(obj)：对象序列化
pickle.loads(bytes)：反序列化对象
json模块：
ison.dump(obj, file)：对象持久化（先序列化，在持久化）
ison.load(file)：反持久化，将数据从磁盘重新读成对象
ison.dumps(obj)：对象序列化
ison.loads(bytes)：反序列化对象
十、面向对象
类（class）：对一些相似特性的事物的抽象总结，抽象概念。
对象（object）：一类事物的一个具体案例，实实在在的案例（实例）
定义类：
python定义类使用，class关键定义。
class 类名称: # 类名称的命名规范遵循大驼峰法
class 类名称(父类):
class 类名称(Object):
面向对象的三大特征：
封装：
在面向对象中：
1、所有的面向对象相关功能，封装在一个类里面
2、在一个类中，将属性私有化，外界不允许访问属性，
一般通过提供公开的方法（getter、setter）来访问和设置
封装的本质：就是对类中属性的数据的保护，不允许外界非法访问
只允许，通过提供的公开的方式来访问数据！！！
将属性私有化之后，如何在外界访问该属性？
1、直接提供get和set方法
2、将get和set再次包装一把，之后使用类似于属性的方法私有的属性
3、使用@property的装饰器完成封装
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)
继承
后代会继承先代的特征或者特征
子类会继承父类的一些方法（父类允许继承的方法）
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()
多态
面向对象中，多态：父类引用指向子类实例的现象！
ArrayList al = new ArrayList(); // 创建一个ArrayList对象
List list = new ArrayList(); // 父类引用指向子类实例的现象！！！
十一、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)
生成器的遍历：
使用for循环可以遍历生成器
for 变量 in generator:
print(该变量每一次循环就是一个生成器的值)
第二种列表生成器的写法：
如果列表推导式过于复杂，想使用这种方式[表达式]非常困难
针对于这种情况，一般使用函数来完成该列表的初始化
将函数转换为列表生成，使用关键字yield
注意：当函数转换为列表生成器时，函数的执行顺序
迭代器（Iterator）：
可以通过next函数调用，并且返回下一个值的对象
可迭代对象（Iterable）：
能够被循环调用，返回下一个值的，可迭代对象
字符串、列表、元组、字典、集合
闭包（closure）：
能够方法函数内部的变量的函数，被称为闭包
闭包：导致函数常驻内存，无法被释放！！！！
局部变量全局化：避免了全局污染！！！
装饰器：
装饰者设计模式的体现，当我们对原有功能不能满足的时候，
我们可以通过装饰原有代码，来实现代码增强
python提供的装饰器（Decorator），就是强化和装饰原有函数功能，
将函数功能加强的一种语法
python的装饰器，它运行流程
十二、异常处理
非正常的一种软件奔溃的现象，称为异常
异常进行处理，本质是一种软件的容错性
抓捕异常：
判断代码可能会出现异常
try:
可能出异常的代码
except:
可能出现的异常
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()
来源：当兵回来你可还在
