Python基础（上）
参考：
⽬录
⼀、数据类型
string、list和tuple都属于quence（序列）。三者都可以进⾏截取，索引值以0为开始值，-1为从末尾的开始位置。加号+是字符串的连接符。星号*表⽰复制当前字符串，紧跟的数字为复制的次数。
1. 数字(Number)
⽤于存储数值，每个变量在使⽤前都必须赋值。数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
a = 5
a =
青州美食b =
c = 1 # 多个变量赋值
a, b, c = 1, 2, 5.6
2. String（字符串）
在Python3中，所有字符串都是Unicode字符串。( Python的注释: 单⾏注释以#开头, ⾏注释⽤三个单引号 '' 或三个双引号 "" 将注释括起来 )
a. 字符串截取
print (str) # 输出字符串 Hello
print (str[0:-1]) # 输出第⼀个到倒数第⼆个的所有字符, Hell
b. 使⽤反斜杠(\)转义特殊字符，在字符串前⾯添加⼀个r则不会转义
print(r"Hello\nWorld") # 不换⾏，直接输出Hello\nWorld
print ("我叫 %s 今年 %d 岁!" % ('⼩明', 10)) 字符串格式化
c. python三引号允许⼀个字符串跨多⾏，字符串中可以包含换⾏符、制表符以及其他特殊字符。
para_str = """这是⼀个多⾏字符串的实例
多⾏字符串可以使⽤制表符TAB ( \t )。
"""
3. List（列表）
列表中元素的类型可以不相同，它⽀持数字，字符串甚⾄可以包含列表（所谓嵌套）。
employee = [1, 'Amy', 23, 'China', 27000.00]
company = ['ABC', 'US']
print(employee[1:3] * 2) # 从第⼆个开始输出到第三个元素, 输出两次 ['Amy', 23, 'Amy', 23]
print(employee + company) # [1, 'Amy', 23, 'China', 27000.00, 'ABC', 'US']
employee[1:3] = ['Sandy', 18] # list元素可以改变
del employee[2] # 可以使⽤ del 语句来删除列表的的元素
4. Tuple（元组）
元组与字符串类似，可以把字符串看作⼀种特殊的元组。
a. 元组的定义
tuple = (1, 'Amy', 23, 'China', 27000.00)
tup1 = () # 空元组
tup2 = (20,) # ⼀个元素，需要在元素后添加逗号，否则括号会被当作运算符使⽤,tup2 = (20)表⽰整数
t = 1, 2, 'a'# t[0]=1 t=(1, 2, 'a')
u = t, (1, 2, 3, 4, 5) # u=((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
b. 截取
print (tuple[0:-1]) # 截取
tup3 = tup1 + tup2; # 创建⼀个新的元组，元组中的元素值是不允许修改的，但我们可以对元组进⾏连接组合
del tup #元组中的元素值是不允许删除的，但我们可以使⽤del语句来删除整个元组
c. 函数应⽤
def test1(a,b): #函数返回多个值的时候，是以元组的⽅式返回的。
return (a,b)
def test2(*args): #python中的函数还可以接收可变长参数，参数名以*开头，该参数的类型也是元组
return args
5. Set（集合）
集合（t）是⼀个⽆序不重复元素的序列。基本功能是进⾏成员关系测试和删除重复元素。可以使⽤⼤括号{}或者t()函数创建集合。 注意：创建⼀个空集合必须⽤t()⽽不是{}，因为{}是⽤来创建⼀个空字典。
a. 成员测试
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Ro'}
if('Ro'in student) :
print('Ro 在集合中')
b. 集合计算
s1 = t('abracadabra'); s2 = t('alacazam')
print(s1 - s2) # s1和s2的差集 {'b', 'd', 'r'} |表⽰并集 &表⽰交集 ^表⽰s1和s2中不同时存在的元素
6. Dictionary（字典）
字典（dictionary）是Python中另⼀个⾮常有⽤的内置数据类型。列表是有序的对象结合，字典是⽆序的对象集合。字典当中的元素是通过键来存取的，键(key)必须使⽤不可变类型。创建空字典使⽤{}
dict = {'Name': 'Amy', 'Age': 18}
纹身的女人dict['Age'] = 20; # 更新 Age
dict.clear() # 清空字典
del dict # 删除字典
判断对象类型
type(a) # <class 'int'>
isinstance(a, int) # True
区别:type()不会认为⼦类是⼀种⽗类类型。isinstance()会认为⼦类是⼀种⽗类类型。
class A:
pass# 如果没有内容，可以写pass，但是如果不写pass就会语法错误
class B(A):
pass
print(type(B(), A) # Fal
print(isinstance(B(), A) # True
遍历字典
fruit = {'a': 'apple', 'b': 'banana'}
for k, v in fruit.items():
print(k, v)
6. 列表的变形
# 列表基本⽅法
ls = ['a', 'b', 'c']
ls.inrt(1, 'a1') # ['a', 'a1', 'b', 'c']
ls.append('d') # ['a', 'a1', 'b', 'c', 'd']
ls.index('b') # 2
ls.sort() # ['a', 'b', 'c', 'd']
#遍历列表
for i, v in enumerate(['a', 'b', 'c']):
print(i, v)
# 使⽤zip()组合同时遍历两个或更多的序列
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))
#反向遍历⼀个序列, 正向使⽤sorted
for i in reverd(range(1, 10, 2)):
print(i) #9 7 5 3 1
# 将列表当做堆栈使⽤（后进先出）
stack = ['a', 'b', 'c']
stack.append('d') # ['a', 'b', 'c', 'd']
stack.pop() # ['a', 'b', 'c']
# 将列表当作队列使⽤（先进先出）
from collections import deque
queue = deque(['a', 'b', 'c'])
queue.append('d') # deque(['a', 'b', 'c', 'd'])
queue.popleft() # deque(['b', 'c', 'd']) 从头部弹出较慢，所有元素都要移位
# 列表推导式
# 使⽤for循环对列表中的每个元素进⾏表达式计算，从⽽⽣成新的列表
fruit = [' banana', ' appke ']
[f.strip() for f in fruit] #['banana', 'apple']
vec = [2, 4, 6]
[3*x for x in vec] # [6, 12, 18]
[[x, x**2] for x in vec]# [[2, 4], [4, 16], [6, 36]]
[3*x for x in vec if x > 3] #[12, 18]
vec2 = [4, 3, -9]; [x*y for x in vec1 for y in vec2] #[8, 6, -18, 16, 12, -36, 24, 18, -54]
[str(round(355/113, i)) for i in range(1, 6)] # ['3.1', '3.14', '3.142', '3.1416', '3.14159']
# 嵌套列表解析
# 将3X4的矩阵列表转换为4X3列表
matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
# ⽅法1
[[row[i] for row in matrix] for i in range(4)]
# ⽅法2
transpod = []
for i in range(4):
transpod.append([row[i] for row in matrix])
# del 语句
ls = ['a', 'b', 'c', 'd', 'e', 'f']
del ls[0] # ['b', 'c', 'd', 'e', 'f']
del ls[2:4] # ['b', 'c', 'f']
del ls[:] # []
del ls # []
# 字典推导
{x: x**2 for x in (2, 4, 6)} # {2: 4, 4: 16, 6: 36}
⼆、运算符
1. 算术运算符： + - * / % **(求幂) //(整除，返回商的整数部分)
5 / 2 = 2.5
外汇操盘手5 // 2 = 2
5 ** 2 = 25
2. 位运算符： & | ^(异或) ~(取反) << (左移) >> (右移)
3. 逻辑运算符： and or not(⾮)
4. 成员运算符： in 、not in
5. ⾝份运算符： is 、is not
is ⽤于判断两个变量引⽤对象是否为同⼀个， == ⽤于判断引⽤变量的值是否相等。
a = 20
b = 20
if ( a is b ): # True
print ("a 和 b 有相同的标识")
if ( id(a) == id(b) ): # True
print ("a 和 b 有相同的标识")
a = [1, 2, 3]
b = a # a is b, a和b指向同⼀对象
b = a[:] # a is not b, a和b指向不同对象
三、条件和循环控制语句
条件控制
def fab(n):
if n<1:
print('输⼊有误！')
return -1
elif n==1 or n==2:
return 1
el:
return fab(n-1)+fab(n-2)
循环控制
# Fibonacci ries: 斐波纳契数列 1,1,2,3,5,8
a, b = 0, 1
while b < 10:
print(b, end=',')
a, b = b, a+b
quence = [1,1,2,3,5,8]
for item in quence:
print(item)
for index, item in enumerate(quence):
print(index, item)
# 求整数1-100的和
sum = 0
for i in range(0,101): # 或 for i in range(101)
sum += i
print(sum)
打勾符号迭代器
迭代是Python最强⼤的功能之⼀，是访问集合元素的⼀种⽅式。迭代器对象从集合的第⼀个元素开始访问，迭代器只能往前不会后退。迭代器有两个基本的⽅法：iter() 和 next()。字符串，列表或元组对象都可⽤于创建迭代器。
1.使⽤for循环迭代
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end="")
2.使⽤next()函数迭代
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))世界武器
except StopIteration:
⽣成器
在 Python 中，使⽤了 yield 的函数被称为⽣成器（generator）。⽣成器是⼀个返回迭代器的函数，
每次遇到 yield 时函数会暂停并保存当前所有的运⾏信息，并在下⼀次执⾏ next() 返回 yield的值, ⽅法时从当前位置继续运⾏。
import sys
def fibonacci(n): # ⽣成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f是⼀个迭代器，由⽣成器返回⽣成。只需返回迭代器，⽽不⽤返回整个斐波那契列表
while True:
try:
print (next(f), end="") # 使⽤迭代器
except StopIteration:
四、函数
函数是组织好的，可重复使⽤的，⽤来实现单⼀，或相关联功能的代码段。函数能提⾼应⽤的模块性，和代码的重复利⽤率。Python提供了许多内建函数，你也可以⾃定义函数。
1. 可更改(mutable)与不可更改(immutable)对象
在python中，string、tuple和number是不可更改的对象，重新赋值不会修改原来的对象，⽽是⽣成
⼀个新的对象。⽽list,dict等则是可以修改的对象。python函数的参数传递类似c++的参数传递，如果传的是不可变类型，则函数中的任何操作不会影响传递的对象本⾝。如果是可变类型如列表、字典，则类似c++的引⽤传递，可以在函数中修改对象的值。
1.不可变类型参数
def changeInt( a ):
a = 10
b = 2
changeInt(b)
print( b ) # 结果是 2
2.可变类型参数
def changeList( mylist ):
mylist[1]=5
return
mylist = [1,2,3];
changeList( mylist );
print (mylist) # 结果是[1,5,3]
2. 函数调⽤
1.关键字参数: 函数调⽤时使⽤参数的顺序与声明时不⼀致，因为 Python 解释器能够⽤参数名匹配参数值
fibonacci ( n = 10 )
2.默认参数：函数定义中设置默认参数值，如果调⽤时没有传递参数，则会使⽤默认参数。默认参数要放在最后⾯，否则会报错。
def printinfo(name, age=35):
print (name, age)
3.不定长参数
def printinfo(*args):
print (args)
printinfo(1, 'Amy', 18)
4.函数参数
def printInfo () :
print ("Hello, world!")
去湿气吃什么药def execute(f):
f() # 执⾏函数
execute(printInfo)
3. 匿名函数
python 使⽤ lambda 来创建匿名函数。所谓匿名，即不再使⽤ def 语句这样标准的形式定义⼀个函数。lambda的主体是⼀个表达式，⽽不是⼀个代码块。lambda 函数拥有⾃⼰的命名空间，且不能访问⾃⼰参数列表之外或全局命名空间⾥的参数。匿名函数也能使⽤关键字参数和默认参数。
sum = lambda arg1, arg2: arg1 + arg2;
print ("sum = ", sum( 10, 20 ))
4. 变量作⽤域
Python 中只有模块，类以及函数（def、lambda）才会引⼊新的作⽤域，其它的代码块（如 if/el、for/while等）是不会引⼊新的作⽤域的，即这些语句内定义的变量，外部也可以访问。Python的作⽤域⼀共有4种，代码中的变量以 L –> E –> G –>B 的规则查找，即在局部找不到，便会去闭包找，然后是全局，再者去内建中找。
L （Local）局部作⽤域
E （Enclosing）闭包函数外的函数中
G （Global）全局作⽤域
B （Built-in）内建作⽤域
内置作⽤域是通过⼀个名为builtin的标准模块来实现的，但是这个变量名⾃⾝并没有放⼊内置作⽤域内，所以必须导⼊这个⽂件才能够使⽤它。在Python3.0中，可以使⽤以下的代码来查看到底预定义了哪些变量:
>>> import builtins
>>> dir(builtins)
x = int(2.9) # 内建作⽤域
g_count = 0 # 全局作⽤域，全局变量可以在整个程序范围内访问
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作⽤域，局部变量只能在其声明的函数内使⽤
强化书
global 和 nonlocal关键字
函数中修改全局变量
num = 1
def fun1():
global num # 需要使⽤ global 关键字声明
print(num)
num = 123
print(num)
fun1()
修改嵌套作⽤域（enclosing 作⽤域，外层⾮全局作⽤域）中的变量则需要 nonlocal 关键字
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
五、模块
模块是⼀个包含所有你定义的函数和变量的⽂件(.py⽂件)。模块可以被别的程序引⼊，以使⽤该模块中的函数等功能。这也是使⽤python 标准库的⽅法。
黑胡椒粉和白胡椒粉import 语句
⼀个模块只会被导⼊⼀次，不管你执⾏了多少次import。当我们使⽤import语句的时候，Python解释器通过python搜索路径查找相应模
