python实用派
第一章 python是什么？初始化
第二章 python基础内容(1)
第三章 python基础内容(2)
第四章 python进阶之numpy库
第五章 python进阶之pandas库
第六章 python进阶之求解器应用–gurobi求解器
第七章 python进阶之求解器应用–cplex求解器
第八章 python进阶之数据可视化篇
第九章 python进阶之爬虫篇
一. 基础
python通过缩进来区分代码块，而不是像c语言那样通过大括号{}，所以，要严格重视缩进，通常用tab来进行缩进。
python的符号需要使用英文模式的除了字符串中的标点符号，其他地方的需要使用英文标点符号。
万物皆对象 所有字符串数字变量等都装在了盒子里
1. Python 保留字符
这些保留字不能用作常数或变数，或任何其他标识符名称，所有 Python 的关键字只包含小写字母。
| 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|
| and | exec | not | assert | finally | or |
| break | for | pass | class | from | |
| continue | global | raise | def | if | return |
| del | import | try | elif | in | while |
| else | is | with | except | lambda | yield |
可以理解为 一些特定的函数
比如很常用的 and break for print def if 等等，其实都是相当于定义好的一些函数，
python的基础很大一部分是学习他们的用法
2. 字符串
字符串就是一系列字符一般用双引号或单引号括起来的就是字符串
比如说
"Hello World"
'我今天吃饭了'
1) 关于字符串的查询
python的字串列表有2种取值顺序（索引顺序）：
| C | o | l | u | m | n |
|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 |
| -6 | -5 | -4 | -3 | -2 | -1 |
input[0] str1 = 'Column'
input[1] print(str1[0])
output[0] 'C'
input[2] print(str1[-1])
output[1] 'n'
- 切片
切片就是选取一部分
规则：取左不取右
input[3] print(str1[0:2])
# 第一个参数为起始序号，第二个参数为终止序号。取第1，2个字符
output[1] 'Co'
input[3] print(str1[0:3:2])
# 第三个参数为步长，即隔几个数取一次
output[1] 'Cl'
2) 关于字符串的合并
利用加号“+”可以合并字符串
input[0] str1 = 'Column'
input[1] str2 = 'Column'
input[2] print(str1+str2)
output[0] 'ColumnColumn'
input[3] print(str1*3)
output[1] 'ColumnColumnColumn'
3. 数字
python中数字有四种类型：整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int，表示为长整型
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j
input[0] num1 = 1.23
input[1] num2 = 123
input[2] print(num1)
output[0] 1.23
input[3] print(num2)
output[1] 123
1) 关于数字的运算
| 符号 | 含义 |
|---|---|
| + | 相加 |
| - | 相减 |
| * | 相乘 |
| / | 相除 |
| // | 地板除，去小数取整 |
| % | 求余数 |
| ** | 乘方 |
| == | 相等 |
| ！= | 不等 |
| >= | 大于等于 |
| <= | 小于等于 |
| > | 大于 |
| < | 小于 |
| & | 按位与(二进制中，同为1则为1，否则为0) |
| | | 按位或(二进制中，两者之一为1即为1，全为0为0) |
| ^ | 按位异或(二进制中，两者不同时则为1，否则为0) |
| ~ | 按位取反(1变为0，0变为1) |
| += | num+=1 与 num=num + 1同义 |
| -= | num-=1 与 num=num - 1同义 |
| *= | num*=1 与 num=num * 1同义 |
| /= | num/=1 与 num=num / 1同义 |
2) 关于格式化
| 符号 | 含义 |
|---|---|
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数 |
| str(num) | 将num变为字符串格式 |
| int(num) | 将num变为整数格式 |
| float(num) | 将num变为浮点数格式 |
4. 变量
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
- 等号 = 用来给变量赋值。
- = 左边是一个变量名，= 右边是存储在变量中的值。
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
#
a = b = c = 1
a, b, c = 1, 2, "john"
*. 一些事项
- 可以用type()方法判断变量类型
a = 100 # 赋值整型变量 b = 1000.0 # 浮点型 c = "John" # 字符串 print(type(a)) print(type(b)) print(type(c)) #输出结果： <class 'int'> <class 'float'> <class 'str'> - 有些变量可以相互转换
a = 100 # 赋值整型变量 b = 1000.0 # 浮点型 c = str(a) # 字符串 d = str(b) print(type(a)) print(type(b)) print(type(c)) print(type(d)) #输出结果： <class 'int'> <class 'float'> <class 'str'> <class 'str'> - 布尔类型 bool
True和False 真和假（1和0）
二. 三大金刚—列表、元组、字典
1. 列表
列表算是核心，使用极其频繁，列表能塞的东西很多，像数字，字符串，列表，字典，元组全能塞。（可以套娃，有点‘’大饼卷一切‘’内味了）
列表，用方括号[ ]括起来表示列表，并用逗号隔开其中的元素。
如
list1 = [1,2,3,'Chang','red',['No','Ok']]
对于列表的操作，不外乎 增删改查，下面进行介绍。
1）查
与前面字符串的查询类似，首先掌握索引
list1 = [1,2,3,'Chang','red',['No','Ok']]
print(list1[0])
#输出结果： 1
print(list1[-1])
#输出结果：['No','Ok']
print(list1[-1][0])
#输出结果：No
print(list1[0]+list1[1])
#输出结果：3
- 切片
对列表的一部分进行查询等操作
如果切片长度大于1，则会切出一个列表list1 = [1,2,3,'Chang','red',['No','Ok']] print(list1[1:3]) #输出结果： [2,3] print(list1[0:4:2]) # 与字符串切片一样，也可以设置步长 #输出结果：[1, 3]关于切片更多的一些规则
切片时
如：[0:2]，可以写为[:2] [0:-1]，可以写为[:] [1:-1]，可以写为[1:]list1 = [1,2,3,'Chang','red',['No','Ok']] print(list1[1:3]) #输出结果： [2,3] print(list1[0:4:2]) # 与字符串切片一样，也可以设置步长 #输出结果：[1, 3] print("我喜欢的颜色是:",list1[4]) print("我的姓氏是:"+list1[3]) # 字符串可以用加号表连接，但如果是数字则会导致 《字符串+数字》，这是不可行的 print("我喜欢的数字是:",list1[1]) #输出结果：我喜欢的颜色是 red/ 我的姓氏是Chang/ 我喜欢的数字是 2
2）改
list1 = [1,2,3,'Chang','red',['No','Ok']]
list1[1] = 1
print(list1)
#输出结果： [1, 1, 3, 'Chang', 'red', ['No', 'Ok']]
list1[:2] = ['s','q']
print(list1) # 与字符串切片一样，也可以设置步长
#输出结果：['s', 'q', 3, 'Chang', 'red', ['No', 'Ok']]
3）增
-
append() 方法
在末尾添加元素,(可以是列表，元组等元素)
如：list1 = [1,2,3,'Chang','red',['No','Ok']] list1.append('abs') print(list1) #输出结果： [1,2,3,'Chang','red',['No','Ok'],'abs'] list2 = [] list2.append(1) list2.append(2) list2.append(3) list2.append('Chang') list2.append([2,3]) print(list2) #输出结果：[1, 2, 3, 'Chang',[2,3]] -
insert() 方法
在任意位置插入元素list1 = [1,2,3,'Chang','red',['No','Ok']] list1.insert(0,'abs') print(list1) #输出结果：['abs', 1, 2, 3, 'Chang', 'red', ['No', 'Ok']] list1.insert(2,[1,2]) print(list1) #输出结果：['abs', 1, [1, 2], 2, 3, 'Chang', 'red', ['No', 'Ok']] -
extend() 方法
可以合并两个列表list1 = [1,2,3] list2 = ['Chang','red',['No','Ok']] list1.extend(list2) print(list1) #输出结果：[1, 2, 3, 'Chang', 'red', ['No', 'Ok']]
4）删
-
del 语句
根据索引，直接删除对应元素
如list1 = [1,2,3,'Chang','red',['No','Ok']] del list1[0] print(list1) #输出结果：[2, 3, 'Chang', 'red', ['No', 'Ok']] del list1[:2] print(list1) #输出结果：['Chang', 'red', ['No', 'Ok']] -
pop() 方法
弹出末尾的一个元素，(可以将这个元素赋值给变量来进行使用或其他操作)
如list1 = [1,2,3,'Chang','red',['No','Ok']] element1 = list1.pop() print(list1) #输出结果：[1, 2, 3, 'Chang', 'red'] print(element1) #输出结果：['No', 'Ok']弹出任意位置的一个元素，根据索引进行操作list1 = [1,2,3,'Chang','red',['No','Ok']] element1 = list1.pop(0) print(list1) #输出结果：[2, 3, 'Chang', 'red'，['No', 'Ok']] print(element1) #输出结果：1 -
remove() 方法
根据元素值进行删除（不知道索引的时候可以用remove(),但是只会删除第一次检索到的该元素，有相同值时只移除检索到的第一个元素）
如list1 = [1,1,3,'Chang','Chang',['No','Ok']] list1.remove(1) print(list1) #输出结果：[1, 3, 'Chang', 'Chang', ['No', 'Ok']] list1.remove('Chang') print(list1) #输出结果：[1, 3, 'Chang', ['No', 'Ok']]
5）关于列表的一些 函数 方法
- len()
返回列表长度 - list()
将元组转为列表 - .count()
返回列表某元素的个数 - .sort()
方法 按字母顺序对列表元素进行排序，会更新原列表，永久性修改顺序 可输入参数（reverse=True）进行逆序排序(不支持数字和字符串一起排) - sorted()
函数 对列表元素进行排序，不会更新原列表，返回一个排序后的列表，可输入参数（reverse=True）进行逆序排序 - .reverse()
方法 反转列表，会更新原列表，永久性修改 - reversed()
函数 反转列表，不会更新原列表，返回一个排序后的列表 - max()
返回列表元素最大值 - min()
返回列表元素最小值
list1 = [1,1,3,'Chang','Chang',['No','Ok']]
print(len(list1))
print(list1.count(1))
# 输出结果：6 2
list1 = ['Chang','Sheng','AS']
list1.sort()
print(list1)
list2 = sorted(list1, reverse=True)
print(list2)
# 输出结果：['AS', 'Chang', 'Sheng'] ['Sheng', 'Chang', 'AS']
list1.reverse()
print(list1)
# 输出结果：['Sheng', 'Chang', 'AS']
2. 元组
元组，用圆括号()括起来表示元组，并用逗号隔开其中的元素。
元组看起来像列表，但是是不可变的，不能进行增删改的操作换句话说，元组就像是不能变化的列表
听起来列表是要强于元组的，为什么还要用元组呢？
元组的查询速度更快，占用内存更小，安全性更高。
（另外元组可哈希（简单理解为不变性），可以作为字典的键，而列表和字典不可哈希（可变），不能作为字典的键）
- 查询方式与列表相同
有意思的一点
tuple1 = (1,2,'Chang',['s','q'])
tuple1[3].append('ing')
print(tuple1)
# 输出结果：(1, 2, 'Chang', ['s', 'q', 'ing'])
元组内有可变元素，可以原地更改
tup = 4, 5, (6, 7)
a, b, (c, d) = tup
print(d)
#输出结果：7
3. 字典
字典可能是Python最为重要的数据结构
字典可以分为两个部分｛键1:值1, 键2:值2, 键3:值3｝一组组的键值对，用冒号：进行组对儿。
用大括号{}括起来，键一般为可哈希对象，而值可以是任何的python对象，功能非常强大。
1）查询
-
指定键进行查询
dic1 = {'First name': 'CH', 'Last name': 'SQ'} print(dic1['First name']) # 输出结果：CH -
查看键值对
通过.items()查看所有键值对dic1 = {'First name': 'CH','Last name': 'SQ'} print(dic1.items()) # 输出结果：dict_items([('First name', 'CH'), ('Last name', 'SQ')]) a = list(dic1.items())[0] #dict_items对象转换为列表在进行查看 print(a) # 输出结果：('First name', 'CH') /是元组的形式 -
查看键
dic1 = {'First name': 'CH','Last name': 'SQ'} print(dic1.keys()) # 输出结果：dict_keys(['First name', 'Last name']) a = list(dic1.keys())[0] #dict_keys对象转换为列表在进行查看 print(a) # 输出结果：First name -
查看值
dic1 = {'First name': 'CH','Last name': 'SQ'} print(dic1.values()) # 输出结果：dict_values(['CH', 'SQ']) a = list(dic1.values())[0] #dict_values对象转换为列表在进行查看 print(a) # 输出结果：CH
2）增加键值对
通过如下方式
dic1 = {'First name': 'CH',
'Last name': 'SQ'}
dic1['Middle name'] = 'NG'
print(dic1)
# 输出结果：{'First name': 'CH', 'Last name': 'SQ', 'Middle name': 'NG'}
3）修改
dic1 = {'First name': 'CH',
'Last name': 'SQ',
'Middle name': 'NG'}
dic1['Middle name'] = 'ING'
print(dic1)
# 输出结果：{'First name': 'CH', 'Last name': 'SQ', 'Middle name': 'ING'}
4）删除
- del
del 指定键名 直接删除整条数据dic1 = {'First name': 'CH', 'Last name': 'SQ', 'Middle name': 'NG'} del dic1['Middle name'] print(dic1) # 输出结果：{'First name': 'CH', 'Last name': 'SQ'} - pop() 方法
指定键名 直接弹出对应的值dic1 = {'First name': 'CH', 'Last name': 'SQ', 'Middle name': 'NG'} element1 = dic1.pop('Middle name') print(dic1) print(element1) # 输出结果：{'First name': 'CH', 'Last name': 'SQ'} NG
5）嵌套
字典的键一般为可哈希对象，但值可以包括任何对象，甚至是字典（进行套娃）
dic1 = {1: 'A',
2: 'B'}
dic2 = {3: 'C',
4: 'D'}
list1 = [1,2,3]
tuple1 = (1,2,3)
dic3 = {'一': dic1,
'二': dic2,
tuple1:list1}
print(dic3)
# 输出结果：{'一': {1: 'A', 2: 'B'}, '二': {3: 'C', 4: 'D'}, (1, 2, 3): [1, 2, 3]}
三. 逻辑结构
python中比较关键的几个结构是for while 和if，前两者为循环结构，if为判断结构
1. if条件控制
if条件控制语句需要掌握的保留字符主要有三个： if elif else
条件语句的一般形式：
if condition_1:
statement_block_1 # 注意缩进和冒号
elif condition_2:
statement_block_2
else:
statement_block_3
上述代码的操作是
如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
如果 “condition_1” 为False，将判断 “condition_2”
如果 “condition_2” 为 True 将执行 “statement_block_2” 块语句
如果 “condition_2” 为False，将执行"statement_block_3"块语句
三元表达式
将if else 写在一行
a = 'Non-negative' if True else 'Negative'
print(a)
# 输出结果：Non-negative
2. for循环
for循环是在⼀个集合（列表或元组，或其他可迭代对象）中进⾏迭代。for循环的语法是：
list1 = [1,2,3]
for i in list1:
print(i)
# 输出结果：
1
2
3
注意两点：冒号 以及 缩进
for循环相当于装进了一个箱子，如果变量只在箱子内部进行了声明，箱子外面是不能使用的。如果变量在箱子上面进行了声明，是可以在箱子里使用的。
1）对循环进行更多操作
list1 = [1,2,3]
for i in list1:
i+=1
print(i)
# 输出结果：
2
3
4
list1 = [1,2,3]
list2 = []
for i in list1:
i+=1
list2.append(i)
print('对list1中所有的元素加1，操作已完成，结果为：', list2)
# 输出结果：对list1中所有的元素加1，操作已完成，结果为： [2, 3, 4]
list3 = []
for i in range(10):
list3.append(i)
print(list3)
# 输出结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
这里注意一个重要的函数 range(), 可以生成一个范围内的数字，range的三个参数是（起点，终点，步进）；
开头为0时可以省略；
range(1,5),可表示1，2，3，4。
dic1 = {'First name': 'CH',
'Last name': 'SQ',
'Middle name': 'NG'}
for key, value in dic1.items():
print(key,value)
# 输出结果：
First name CH
Last name SQ
Middle name NG
对于字典的遍历也是一个比较重要的点
2）解析用法
用一行代码完成循环的列表创建等任务
list1 = [i**2 for i in range(10)]
print(list1)
# 输出结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
3. while循环
while循环指定了条件和代码，当条件为False或⽤break退出循环，代码才会退出：
while 判断条件(condition)：
执行语句(statements) # 注意缩进和冒号
如：
a = 0
while a<5:
a += 1
print(a)
#输出结果：5
a = 0
while a<5:
a += 1
break
print(a)
#输出结果：1
break 之前提到的保留字符，它的用法是停止当前循环（如果有多层循环，只停止当前层）。
for i in range(2):
print(i,"<--This is i")
for j in range(3,5):
print(j,"<--This is j")
break
# 输出结果
0 <--This is i
3 <--This is j # 没有break的话应该还打印 j=4
1 <--This is i
3 <--This is j
python 中没有像C语言中的do while循环，只有for和while循环
4. 嵌套应用
首先介绍两个常用的保留关键字，continue pass，与break一样，他们经常出现在循环中
continue 用来结束本次循环，开始下一次循环
pass 不做任何事情，一般用做占位语句，保持结构完整性
常用的while和if的嵌套
a = True
b = 1
while a:
b += 1
if b > 3:
a = False
print("b大于3了")
elif b == 3:
print("b等于3了")
continue
elif b:
pass
print("执行了pass")
# 输出结果：
执行了pass
b等于3了
b大于3了
创建一个列表
list1 = [i for i in range(10) if i%3==0]
print(list1)
#输出结果：[0, 3, 6, 9]
四. 迭代器与生成器
节约内存
1. 迭代器
迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的函数：iter() 和 next()。
list1 = [i for i in range(2)]
it = iter(list1)
print(next(it))
#输出结果：0
print(next(it))
#输出结果：1 #只会往前不会后退
print(next(it))
#输出结果：StopIteration # 抛出异常，迭代器中没有值了
也可以用for循环来遍历迭代器
list1 = [i for i in range(5)]
it = iter(list1)
for x in it:
print (x, end=" ")
#输出结果：0 1 2 3 4
for语句本质就是不断调度next函数实现的
2. 生成器
生成器(generator)也是用在迭代操作中，其本质上可以理解为一个特殊的迭代器，生成器具有和迭代器一样的特性。
我们可以通过两种方式创建生成器：生成器表达式，生成器函数。
1）生成器表达式
生成器表达式和列表推导式差不多，我们只需要包列表推导式的[]改为()，这样就是一个生成器表达式了
gen1 = (i for i in range(5))
print(gen1)
#输出结果：<generator object <genexpr> at 0x000002455A5D9190> # 返回了一个生成器
2）生成器函数
普通函数一般通过 return 来返回一个值，当我们使用关键字 yield 来返回值，那么这个带有 yield 的函数就变成了生成器函数。
对于有 yield的生成器函数，每次调用 next() 方法遇到 yield 语句才返回，如果再次调用 next() 方法，那么就会从上次返回的 yield 语句位置继续执行
def a():
a = 1
print(a)
yield a+1
a = 5
print(a)
yield a*2
b=a()
next(b)
#输出结果：1 (并带有返回值2)
next(b)
#输出结果：5 (并带有返回值10)
*. 几个函数
1. enumerate()函数
迭代⼀个序列时，你可能想跟踪当前项的序号。可以通过enumerate()函数实现,返回一个（i，value）元组序列
list1 = [1,2,'Chang',['s','q']]
for i, j in enumerate(list1):
print(i,j)
#输出结果：
0 1
1 2
2 Chang
3 ['s', 'q']
利用enumerate()函数构建一个键为序号的字典
list1 = [1,2,'Chang',['s','q']]
dic1 = {}
for i, j in enumerate(list1):
dic1[i] = j
print(dic1)
#输出结果：{0: 1, 1: 2, 2: 'Chang', 3: ['s', 'q']}
2. zip()函数
用zip()函数可以将两个序列成对组合成⼀个元组列表。（以最短的序列长度为准）
list1 = [1,2,'Chang',['s','q']]
list2 = ['ang','ing','eng','ong']
tuple1 = (0,1,2,3,4,5,6)
zipped = zip(list1,list2,tuple1) # 是一个zip对象
print(list(zipped))
#输出结果：[(1, 'ang', 0), (2, 'ing', 1), ('Chang', 'eng', 2), (['s', 'q'], 'ong', 3)]
生成一个字典
dic2 = {}
for i,j,k in zipped:
dic2[k] = [i,j]
print(dic2)
#输出结果：{0: [1, 'ang'], 1: [2, 'ing'], 2: ['Chang', 'eng'], 3: [['s', 'q'], 'ong']}
python之禅
注意代码的简洁性，要易于理解，编码要规范，注意注释
编码的简洁是python所追求的，当然他的运行速度可能相对有点拉跨。
850
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
