Python语法（1）.md

Python语法（1）.md
Python基础语法
安装新的包
管理员权限打开cmd
输⼊命令>>>conda install chardet
既可以安装chardet包。

第⼆章Python基础语法
标识符
第⼀个字符必须是字母表中的字母或者下划线
⼤⼩写敏感。

其它组成部分为字母数字下划线
等号：
“=”含义为赋值，⽤来定义变量
Python保留字
import keyword
print(keyword.kwlist)
注释：
或 （code)
⾏与缩进
可⽤分号进⾏分割，但是推荐⽤⾏进⾏分割。

输⼊和输出：
Python提供了⼀个input()，可以让⽤户输⼊字符串，并存放到⼀个变量中。

，
print()在括号中加上字符串，就可以向屏幕上输出指定⽂字。

变量
Python中的变量处需要声明。

每个变量在使⽤前都必须赋值，变量赋值之后该变量才会被创建。

在Python中个，变量就是变量，它没有类型，我们所说的类型是变量内存中对象的类型。

使⽤（=）进⾏赋值。

⾃增运算
e.g. >>> a = a+1
or >>> a+=1
运算符描述实例
=简单的赋值运算符c= a+b 将a+b的结果赋值为c
运算符描述实例
+=加法赋值运算 b += a 等价于 b = b+a
-=减法赋值运算 b -= a 等价于b = b-a
x=乘法赋值运算符 b x= 等价于 b= bxa
/=除法赋值运算 b /= a 等价于 b=b/a
%=取模赋值预算b=b%a
xx=幂赋值运算
//=取整除赋值运算符
多个变量赋值
a = b= c=1
e,f,g=1,2,"runoob"
#星号表⽰不定长，例如
a,*b,c=1,2,3,4,5
#此时b为⼀个列表
分⽀主题
第三章 标准数据类型
使⽤ type(a)来查看变量类型。

使⽤isinstance(3,int)查看3是否为整数，返回布尔值。

布尔值 True 和 False,其中0和空序列 为True
1.布尔值 booleans
布尔运算（and,or,not)
2.数字Numbers
整数int
⼩数float
注意，可以⽤int函数或者整除来将⼩数型的数据经过运算转化为整型数据。

第⼀个不同。

⼩数在Python中是不精确存储，可以使⽤包import decimal来解决。

e.g.
decimal.Decimal("1.1")+decimal.Decimal("1.1")+decimal.Decimal("1.1")
此时为精确计算。

第⼆个不同。

整数存储赋值，使⽤id()查看对象的内存存储位置。

当整数⼩于256时，python内部有，可以直接调⽤。

但是浮点类型是不精确存储的，每次新建都是重新创建对象。

数字间的转换。

⽐较运算符与布尔运算？
3.字符串Strings
字符串是以单引号'或双引号"括起来的任意⽂本。

字符串不可修改。

字符串位置是从0开始的。

切⽚函数:[]
String_1[x:y:z]
x起始位置
y终⽌位置
步长
起始位置包含起始位置的索引，终⽌位置不包括终⽌位置的索引。

步长默认为1.
e.g.
str_1[::2]
步长为2.
字符串运算符
"python"+"python"
"python""ssss"
"python"*3
转义字符 ""
\n
换⾏
\t
表⽰制表符,tab键，相当于四个空格。

\
表⽰ \，只在字符串中有效。

r''或者R''
⽤r''表⽰''内字符串默认不转义，也就是使⽤原⽣字符串。

多⾏字符串
三双引号是⽤来多⾏注释的，但是换⾏符会⽤ \n 来表⽰。

e.g.
"""
a 是⼀个数字
b 是⼀个字符串
c 是⼀个列表
"""
返回
'\na 是⼀个数字\nb 是⼀个字符串\nc 是⼀个列表\n'
常⽤字符串⽅法
字符串练习
练习1.1：
已知字符串 s = “sadINDUionaREwSS” ，能否将该字符串前半部分转换⼤写，后半部分转换成⼩写？为什么？（若字符串长度为奇数，中间的字符⼤写。

）
s = "sadINDUionaREwSS"
s[0:int(len(s)/2)].upper()+s[int(len(s)/2):].lower()
练习1.2：
请⽣成字符串s3，s3为s进⾏逆序排序的结果。

for i in range(15):
s3=s3+s[15-i]
s3=s[::-1]
练习1.3：
请基于练习⼀中的截取s中奇数位并转化为⼤写，截取s中偶数位并转换为⼩写。

for i in range(int(len(s))):
if i % 2 == 0:
s1_3=s1_3+s[i].lower()
else:
s1_3=s1_3+s[i].upper()
print(s1_3)
s[::2].upper()
s[1::2].lower()
练习1.4：
"2017/10/15 14:15:45"这个时间的字符串，请截取年份，⽉份，⽇期，时，分，秒
time.split("/")[0]
time.split("/")[1]
time.split("/")[2].split(" ")[0]
time.split("/")[2].split(" ")[1].split(":")[0]
练习1.5：
⽤input输⼊⼀个数字的字符串，然后转换成整型，然后乘以5加上8计算后转换成字符串输出
str(int(a)*5+8)
练习1.6：
str10="aabbccddeeabbbadddd"将⽤A将前2个a替换，然后⽤find函数返回最后⼀个a的索引
str10.rfind["a"]
⼤⼩写
string.upper()
string.lower()
替换
string.replace("y","Y",2); 2表⽰⼀共替换⼏个。

切分函数
string.split('t')#⼀个参数，参数为分隔符。

如果没有的话，默认使⽤空格进⾏切分。

拼接⽅法
"th".join(['py','on py','on']);使⽤th把序列中的元素拼接到⼀起。

如果后⾯是⼀个字符串，则在字符串的每个单元之间拼接th。

计数
string.count("y")
去掉空格
string.strip();string.lstrip();string.rstrip()
查找字母位置
string.find("y",4,7)在4到7的位置上找y。

格式化字符串
注意，format前⾯为“点”不是“逗号”
for i in range(4):
print("i的值为{}，i的平⽅为{}，i的⽴⽅为{}".format(i,i2,i3))
in
"a" in str_2;判断a是否在字符串中，返回值为布尔值。

4. 列表
列表就是⽤来存储⼀连串元素的有序的容器，⽤[]来表⽰。

L=[1,2,3,4,"str"]
L[0]=78
与字符串有重要区别，列表是可以修改的。

赋值不需要位数相等，但是需要值也为列表形式。

赋值需要前后类型相同。

但是个数不⼀定相同。

L[1:3]=[45] #成功
L[1:3]=45#失败，需要前后的类型相同。

常⽤⽅法
练习1.7：
列表L，[2,5,3,8,10,1],对其进⾏升序排序并输出
L=[2,5,3,8,10,1]
L.sort(reverse=False)
L
练习1.8：
字符串s，"123456"，将其转化成列表逆序并输出
S=list(s)
S.reverse()
S
练习1.9：
l=[1,2,3]有⼏种⽅法可以扩展成[1,2,3,4,5,6]
L.extend([4,5,6])
L+[4,5,6]
练习1.10：
List=[1,3,5,7,9,0,2,4,6,8]使⽤切⽚得到[4, 0, 7]，[5, 9, 2, 6]
List[7:2:-2]
List[2::2
添加元素
L.append("x");不管x是什么对象类型，只能添加成原有列表中的⼀个元素。

减少元素
L.pop()
删除列表中最后⼀个元素，然后返回这个元素。

插⼊元素
L.insert(1,"python");将“python”这个字符串插到索引为1的位置
拼接列表
L.extend([5,6,7]);吧[5,6,7]和L进⾏拼接，与append相⽐，会将列表连接在原列表后。

列表运算
加法为拼接，乘法为复制n次
计数
L.count(4)
索引切⽚
L[-1][1]
移除元素
L.remove(45)，参数为列表⾥⾯的值
逆序/降序
L.reverse()与L[::-1]不同。

排序
需要列表内元素是同质的，或者有⼀定规则可以排序。

L=[1,3,2,7,3]
L.sort()
L1=["aaabbd","ccccddddd","ffsas"]
L1.sort(key=len) #按照长度排序
L1.sort(key=len,reverse=Ture) #降序排列
清空
L.clear()
list()
将字符串转化为列表
5.元组
与列表相似，但是不能修改。

常⽤(34,55,66)表⽰。

但是如果元组之中有列表的话，可以修改其中的列表。

可以这样理解，列表是⼀种容器，如果新建⼀个列表L=[1,2,3]然后查看它在内存中的位置id(L).然后向列表中添加元素L.append(4)，此时查看id(L)，会发现两个id相同，说明L没有变。

a= 4,5,6
a,b,c = 4,5,6
6.字典Dictionaries
字典使⽤ 键-值（key-value）存储，具有极快的查找输⼊速度，也需要⼤量内存。

字典的每个key-value对⽤冒号分割。

字典中的每个 键key 是唯⼀的、不可变的，但是 值value 可以重复。

dca={'Atom':25,'BIG':35,'Kid':40}
字典练习
练习1.11:
建⼀个字典，添加新的键值对，在此基础上更新另外⼀个字典，在将字典以列表的⽅式返回。

dict_1 = {"a":1,"b":2,"c":3}
type(dict_1)
dict_1["e"]=5
dict_1.update({"d":4})
list(dict_1.items())
练习1.12：
Dict={"d":"banana","a":"apple","b":"grape","c":"orange"}转换成列表⽤键进⾏排序。

l=list(Dict.items())
l.sort()
l
练习1.13：
d={"a":1,"b":2,"c":3},分别输出它的key与value。

向其插⼊字典{"d":4}
d.keys()
d.values()
d_1={"d":4}
d.update(d_1)
d
常⽤操作
创建字典
dca={'Atom':25,'BIG':35,'Kid':40}
新增键值对
dca["lucy"]=98
修改键值对
dca["lucy"]=80
查询键值对
dca["lucy''];根据键来找值。

删除键值对
del dca["lucy"]
常⽤⽅法
删除键值对
dca.pop("lily","No Such Key")
好处是不太容易删错
增加键值对
dca.update({"a":2,"c":5})
转化为列表
list(dca.item())
校验增加
如果dca中存在BIG，则返回字典中BIG的值，如果没有的话，将BIG插⼊到dca中。

dca.setdefault("BIG",11)
返回键/值
dca.keys()
dca.value()
7.集合
set和idct类似，为⼀组key的集合，但不存储value。

由于key不能重复，所以在set中不能有重复的值。

是⽆序的。

8.空值
None，Python中的特殊值。

第四章 控制流语句
使⽤缩进来控制语句层级同缩进的代码被认为是同等级的代码。

练习1.16：
打印出所有的“⽔仙花数”，所谓“⽔仙花数”是指⼀个三位数，其各位数字⽴⽅和
I=[]
for i in range(100,1000):
i=str(i)
if int(i)==int(i[0])**3+int(i[1])**3+int(i[2])**3:
I+=[int(i)]
print(I)
练习1.17：
有四个数字：1、2、3、4，能组成多少个互不相同且⽆重复数字的三位数？各是多少？
I=[]
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
#if i!=j!=k:
if i!=j and j!=k and i!=k:
I+=[int(str(i)+str(j)+str(k))]
len(I)
练习1.24:
华为2016校招（字符集合） 题⽬描述 输⼊⼀个字符串，求出该字符串包含的字符集合 输出描述: 每组数据⼀⾏，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。

输⼊例⼦: abcqweracb 输出例⼦: abcqwer
S=input("请输⼊⼀串字母：")
S_1=S[0]
for i in range(0,len(S)):
if S[i] in S_1:
S_1=S_1
#continue
else:
S_1+=S[i]
print(S_1)
#第⼆种⽅法
"".join(sorted(set(S_1),key=S_1.find))
#先化为集合，因为集合的性质是不能有重复值，但是集合是⽆序的。

#所以需要使⽤sorted()函数进⾏排序，是⼀个⾼级函数。

#排序的依据是原字符串的索引。

key=S_1.find 或者 key=S_1.index
#最后使⽤字符串的join⽅法将这些单独的字符串连接起来。

第⼀节 顺序结构
就是普通的从上到下的代码结构。

顺序结构，⾃上⽽下逐条运⾏
第⼆节 分⽀结构
Python条件语句是通过⼀条或多条语句的执⾏结果（True或False）来决定执⾏的代码块。

#条件判断要求其为布尔值。

if<条件判断1>:
<执⾏语句块1>
elif<条件判断2>:
<执⾏语句块2>
else:
<执⾏语句块3>
age = input("Enter Your Age:")
if int(age) > 60:
print("old man")
elif int(age) > 28:
print("adult")
else:
print("child")
企业发放的奖⾦根据利润提成。

利润(I)低于或等于10万元时，奖⾦可提10%；利润⾼于10万元，低于20万元时，低于10万元的部分按10%提成，⾼于10万元的部分，可提成7.5%；20万到40万之间时，⾼于20万元的部分，可提成5%；40万到60万之间时⾼于40万元的部分，可提成3%；60万到100万之间时，⾼于60万元的部分，可提成1.5%，⾼于100万元时，超过100万元的部分按1%提成，从键盘输⼊当⽉利润I，求应发放奖⾦总数？
I=input("请输⼊当⽉利润（单位：万元）：")
if int(I)<=10:
print(int(I)*0.1,"万元")
elif int(I) <= 20:
print(10*0.1+(int(I)-10)*0.075,"万元")
elif int(I) <= 40:
print(1.75+(int(I)-20)*0.05,"万元")
elif int(I) <= 60:
print(2.75+(int(I)-40)*0.03,"万元")
elif int(I) <= 100:
print(3.35+(int(I)-60)*0.015,"万元")
else:
print(3.95+(int(I)-100)*0.01,"万元")
I=int(input("enter the price"))#可以在输⼊的时候就将其变为整型
#第⼆种⽅法
dollar = int(input("please enter profit:"))
profit = [100,60,40,20,10,0]
i = [0.01,0.015,0.03,0.05,0.075,0.1]
money = 0
for index in range(len(i)):
if dollar>profit[index]:
money+=(dollar-profit[index])*i[index]
dollar=profit[index]
print(money)
第三节 循环结构
⽤来控制⼀段语句的重复执⾏。

Python循环语句
Python中的循环语句有for和while。

Python中通过条件判断来确定是否执⾏循环体。

while循环
while <条件判断>:
<执⾏语句块1>
#完成后再次返回while
else:
<执⾏语句块2>#else在条件语句为false时执⾏else语句块
#else部分可以省略
#对列表进⾏循环判断
L = [4,6,7,8,10]
flag = 1
index = 0
while flag:
if L[index]%2 == 0:
print(L[index])
else:
flag = 0
index = index+1
else:
print("奇数的位置索引：",index-1)
#使⽤变量来控制while循环的停⽌，这样就不⽤使⽤break进⾏跳出了。

#使⽤index对列表中的对象使⽤切⽚器进⾏索引。

for循环
经常搭配range(1,10,2)使⽤，1为起始值，10为终⽌值，2为步长。

只填⼀个数默认为终⽌值。

函数默认从0开始计数。

for i in <可迭代对象>:
<执⾏该语句块1>
else:
<执⾏语句块2>#else中的语句会在循环正常执⾏完（即for不是通过break跳出⽽中断的）的情况下执⾏。

可迭代对象常⽤列表，元组也是可迭代对象。

for i in L[1,2,3,4]:
print(i)#i相当于每次从L中取⼀个元素。

九九乘法表
for i in range(1,10):
for j in range(1,10):
if i>=j:
print(i,"*",j,"=",i*j,end="")
print()
字典中的值如何通过循环取出来。

重点在于，for后边的变量与in后⾯的对象的格式要相对应
dict_1={"a":1,"b":2,"c":3}
for i,j in dict_1.items():
print("i={},j={}".format(i,j))
L=[(1,2,3),[4,5,6]]
#此时 * 表⽰不定量，j的结果为⼀个列表
for i,*j in L:
print("i={},j={}".format(i,j))
输⼊⼀个数字，输出它的⼆进制中的1的个数num = bin(int(input("please enter number:")))
count=0
for i in num[2:]:
if i=="1":
count=count+1
print("这个数字的⼆进制中包含1的个数为:{}".format(count)) #第⼆种⽅法
two=bin(int(input("aaa")))
two.count("1")
print(two,two.count("1"))
#求⼆进制中连续出现1最多的次数
len(max(bin(442)[2:].split("0"),key=len))
终⽌语句
break语法⽤来终⽌最内层的循环
n = 6
while1:
if n%2 == 0:
print(n)
else:
print(n**2)
n-=1
if n == 0:
break
continue
continue⽤来跳过最内层当前次的循环
pass占位语句
pass是空语句，是为了保持程序结构的完整性。

第五章 ⾃定义函数
解⼀元⼆次⽅程
def solve_quar(a,b=0,c=0):
if a==0:
print("请输⼊正确的参数")
return()
elif b**2-4*a*c < 0:
print("没有实数解")
print("结果如下")
return((-b+(b**2-4*a*c)**0.5)/(2*a),(-b-(b**2-4*a*c)**0.5)/(2*a))
⽼师解法
def slove(a,b,c):
if a==0:
print("不是⼀元⼆次")
else:
x=-b/(2*a)
delta=b**2-4*a*c
if delta==0:
print("只有⼀个根")
return x
elif delta>0:
x1=x-math.sqrt(delta)/(2*a)
x2=x+math.sqrt(delta)/(2*a)
print("有2个根x1={}，x2={}".format(x1,x2))
return(x)
else:
print("不考虑")
求欧式距离
#两变量的欧式距离
##两个位置的参数使⽤列表
def oushi(a,b):
return math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2)
oushi([1,2],[3,4])
def oushi(a,b):
dis = 0
for i in range(len(a)):
dis+=(a[i]-b[i])**2
distance = math.sqrt(dis)
return distance
oushi([1,2,3,4],[4,3,2,1])
曼哈顿距离
def manha(a,b):
return sum(map(lambda x,y:abs(x-y),a,b))
manha([2,3],[4,5])
第⼀节 ⾃定义函数的结构
⾃定义函数
其中，map函数规则为：map() 会根据提供的函数对指定序列做映射。

第⼀个参数 function 以参数序列中的每⼀个元素调⽤ function 函数，返回包含每次function 函数返回值的新列表。

map(function, iterable, ...)
lambda为匿名函数，适⽤于只有⼀个条件的简短函数，可直接⽤于条件。

lambda x:x+=1
def func(n):#func为函数名，n 为参数
"""⽤来求n位的⽔仙花数"""
x = 10**(n-1)
y = 10**n
res = []
for i in range(x,y):
if sum(map(lambda x:int(x)**n,str(i)))==i:
res.append(i)
return res#返回变量，并且终⽌函数
调⽤函数
func(3)
第⼆节 函数的参数
必须参数
必须参数⼜称为位置参数，必须以正确的顺序传⼊参数。

调⽤时的数量和位置必须和声明时的⼀样。

def func1(x,y):
return x**y
命名参数
给定参数⼀个默认值，按照顺序来，如下例，当只输⼊⼀个参数的时候，默认y为2，也可以输⼊两个参数，⾃定义y的值。

def func1(x,y=2):
return x**y
输⼊参数的时候也可以带上参数的名称，这样可以不按照顺序来。

func1(y=4,x=2)
默认参数
第三节 return语句
return [表达式]语句⽤于退出函数，选择性地向调⽤⽅式返回⼀个表达式，不带参数的return语句返回None
第四节 变量作⽤域
局部内不能修改全局的变量。

注意，像列表之类的容器，可以使⽤list.append对容器内的内容进⾏修改！ 可以使⽤global 可在局部中指定⼀个全局的变量，并且进⾏修改。

a = 10
def fff():
global a
a=4
print(a)
x = int(2.9)#内建作⽤域
g_count = 0# 全局作⽤域
def outer():
o_count = 1#闭包函数外的函数中
def inner():
i_count = 2#局部作⽤域
print(i_count)
print(o_count)
print(g_count)
inner()
outer()
第五届 递归函数
def func(n):
if n==1:
return1
else:
return func(n-1)*n
第六节 匿名函数
lambda表⽰匿名函数，与⾃定义函数相⽐不占⽤内存，⽤完就可以丢掉了。

func = lambda x:x+x
func(1)
冒号前⾯表⽰函数参数。

匿名函数有个限制，就是只能有⼀个表达式，不⽤写return，返回值就是该表达式的结果。

⽤匿名函数有个好处，因为函数没有名字，不必担⼼函数名冲突。

匿名函数也是⼀个函数对象，可以把匿名函数赋值给⼀个变量，再利⽤变量来调⽤该函数。

⾼级函数
练习1.36:
hh=[11,22,33],在每个元素上加100(分别⽤def和lambda) [11,22,33],[44,55,66],[77,88,99]想得到
[114477,225588,336699] (分别⽤def和lambda)
hh=[11,22,33]
list(map(lambda x:x+100,hh))
def plus100(x):
return x+100
list(map(plus100,hh))
#拼接三个序列
a,b,c=[11,22,33],[44,55,66],[77,88,99]
list(map(lambda x:int(str(a[x])+str(b[x])+str(c[x])),[0,1,2]))
def plus(x):
return int(str(a[x])+str(b[x])+str(c[x]))
list(map(plus,[0,1,2]))
练习1.37:
a=list(range(1,10)) b=list(range(2,20,2))#求a+b，对应的元素相加
练习1.37:
a=list(range(1,10)) b=list(range(2,20,2))#求a+b，对应的元素相加
map
对序列使⽤的函数，类似于循环，遍历⾥⾯的所有元素。

list(map(lambda x:x>0,[1,2,3,4,-6]))
[True, True, True, True, False]
filter
list(filter(lambda x:x>0,[1,2,3,4,-6]))
[1, 2, 3, 4]
reduce
把⼀个函数作⽤在序列上。

filter
filter函数⽤来过滤，第⼀个参数为判断函数，返回布尔值，以此来过滤第⼆个参数（序列）中为TRUE的对象。

def is_odd(x):
"""删掉偶数只保留奇数"""
return x%2==1#返回的是布尔值
list(filter(is_odd,[1,2,3,4,5,6]))
#或者使⽤匿名函数
list(filter(lambda x:x%2==1,[1,2,3,4,5,6]))
zip函数
L=list(zip(["A","B","C"],[1,2,3,4],["d","e","f"]))
#out:[('A', 1, 'd'), ('B', 2, 'e'), ('C', 3, 'f')]
#返回，也就是说将元组打碎,将对应位置的值放在⼀起。

list(zip(*L))
#[('A', 'B', 'C'), (1, 2, 3), ('d', 'e', 'f')]
⾃定义排序
sorted([43,2,-12,4,-24],key=abs)
key⽐较灵活，例如
key=lambda x:x[1]
key=lambda x:len(x[2])
还有⼀个参数 reverse=True 也就是按照倒叙排序
棋盘问题
#棋盘问题
L=[]
n=int(input("请输⼊n的值："))
for i in range(n):
L.append(input("输⼊你的棋盘颜⾊："))
max_b=max(map(lambda x:max(x.split("W")),L))#在⾏中通过W切分的最⼤的长度。

max_w=max(map(lambda x:max(x.split("B")),L))#在⾏中通过W切分的最⼤的长度。

#使⽤zip进⾏转置，看⼀下列的相邻的数量
list(zip(*L))
list(map(lambda x:"".join(x),(zip(*L))))
max_arry_b=max(map(lambda x:max(x.split("W")),L))#在列中通过W切分的最⼤的长度。

max_arry_w=max(map(lambda x:max(x.split("B")),L))#在列中通过W切分的最⼤的长度。

len(max(max_b,max_w,max_arry_b,max_arry_w,key=len))
列表⽣成式
[i if i%2==0else -i for i in range(10) ]
#相当于
L=[]
for i in range(10):
if i%2==0:
L.append(i)
else:
L.append(-i)
L
三元表达式
简便写法的时候if else要放在前⾯，因为是⼀个三元表达式。

10if4>0else3
从matrix中取出每个列表中的顺序个重新⽣成新的列表(列表⽣成器)
matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
[[l[i] for l in matrix] for i in range(4)]
#⽣成⼀个列表
[l[i] for l in matrix for i in range(4)]
[j for i in matrix for j in i]
练习
练习1.40:
strings=["a","as","bat","car","dove","python"]过滤掉长度⼩于等于2的字符串，并将剩下的字符串转换成⼤写字母形式。

strings=["a","as","bat","car","dove","python"]
list(filter(lambda x:len(x)>2,list(map(lambda x:strings[x].upper(),range(len(strings))))))
#第⼆种
[x.upper() for x in list(filter(lambda x:len(x)>2,strings))]
练习1.41：
strings=["a","as","bat","car","dove","python"]创建⼀个指向列表位置的映射关系的字典。

strings=["a","as","bat","car","dove","python"]
{i:j for j,i in enumerate(strings)}
#two
dict(enumerate(strings))
练习1.42:
some_tuples=[(1,2,3),(4,5,6),(7,8,9)]将这个整数元组构成的列表成为⼀个简单的整数列表。

some_tuples=[(1,2,3),(4,5,6),(7,8,9)]
[j for i in some_tuples for j in i]
练习1.43:
all_data=[["Tom","Billy","Jefferson","Andrew","Wesley","Steven","Joe"], ["Susie","Casey","Jill","Ana","Eva","Jennifer","Stephanie"]]我们要找出带有2个或以上的字母e的名字，并将它们放⼊⼀个新列表。

all_data=[["Tom","Billy","Jefferson","Andrew","Wesley","Steven","Joe"], ["Susie","Casey","Jill","Ana","Eva","Jennifer","Stephanie"]] "ee".count("e")
[j for i in all_data for j in i if (j.count("E")+j.count("e"))>=2 ]
字典⽣成式
L=["a","b","c","d"]
{i:j for j,i in enumerate(L)}
#list(enumerate(L))
第六章 错误和异常
异常
1. 语法错误
sy
2. 除0错误 ZeroDivisionError
ZeroDivisionError
3. 访问⼀个错误的⽅法 AttributeError
4. 索引的值超过索引的范围 IndexError
5. 字典的键错误 KeyError
6. 变量名错误 NameError
8. 类型产⽣的错误 TypeError
异常处理
⽤来捕获程序中出现的异常，⽤来保证程序的正常运⾏。

try
<执⾏语句块0>
except <异常信息1>:
<执⾏语句块1>#如果在try部分引发了异常1
except<异常信息2>:
<执⾏语句块2>#如果在try部分引发了异常2
else:
<执⾏语句块3>#如果在try部分没有引发异常
finally：
<执⾏语句块4>#⽆论发⽣什么异常都执⾏，⼀般⽤于打开⽂件最后关闭⽂件。

还有连接数据库最后关闭数据库连接
注：如果except后不写异常的类型信息，那么该except会捕获所有的异常。

如果⼀个except捕获多个异常那么异常信息的位置传⼊包含多个异常的元组即可
e.g.
L=[]
for i in range(4):
try:
a = int(input())
L.append(a)
except ValueError as e:
print("出现了异常，错误信息为{}".format(e))
continue
else:
print("没出现错误")
finally:
print("⼀定会执⾏")
猜数字问题
异常处理习题
猜数字问题
训练内容: 分⽀结构, 循环结构, 异常处理
问题描述: 由系统程序产⽣⼀个 1 - 100 之间的随机整数, 然后去猜测数字是多少, 猜测正确或者猜测次数超过5次, 给出相应提⽰并结束游戏.
import random
count=0
guess = random.randint(1,100)
while True:
try:
count+=1
a = int(input("please enter a number:"))
except ValueError as e:
print("please enter a number,Error is :")
continue
if a > guess :
print("猜⼤了")
elif a< guess:
print("猜⼩了")
else:
print("猜对了，数字为{}".format(a))
if count == 5:
print("guess={}".format(guess))
break
蒙特卡洛模拟计算π
画图
总的思想就是根据四分之⼀圆外切正⽅形的⾯积⽐来计算π。

也就试根据圆的⾯积S=πr^2得到tik = time.time()
count=0
cycle=2**20
x_inp=[]
y_inp=[]
x_out=[]
y_out=[]
#循环
for i in range(cycle):
#⽣成⼀个随机点
x,y=random.random(),random.random()
#判断是否在圆内
if x**2+y**2<1:
count+=1
x_inp.append(x)
y_inp.append(y)
else:
x_out.append(x)
y_out.append(y)
tok= time.time()
pi = 4*count/cycle
print(pi)
print(tok-tik)
画图
import matplotlib.pyplot as plt#画图的包，as后⾯是别名，⽅便调⽤
%matplotlib inline#实时展现
plt.figure(figsize=(8,8))
plt.scatter(x=x_inp,y=y_inp)
plt.scatter(x=x_out,y=y_out,color="r")
第七章 常⽤内置函数
第⼀节 逻辑判断
all(iterable)
如果iterable中值都为真，返回ture，如果iterable为空也返回Ture。

amy(iterable)
有任意⼀个值为真，返回Ture，如果iterable为空返回False
isinstance()
判断参数是否为指定类类型
isinstance(2,int)
第⼆节 数学相关
abs(x)
绝对值
divmod(x,y)
完成除法，返回商和⽟树
pow(x,y[,z])
pow()函数返回以x为底，y为指数的幂。

如果给出z值，该函数就计算x的y次幂被z取模的值。

round(x,[,n])
round()函数返回浮点数x的四舍五⼊值，如给出n值，则代表舍⼊到⼩数点后的位数。

min(x,[,y,z...]
min()函数返回给定参数的最⼩值，参数可以为序列
max(x,[,y,z...])
sum(iterable)
返回序列或集合中数字的综合
第三节 序列相关
len(object)->integer
range([lower,]stop[,step])
第四节 类型转换
bool()
int()
float()
str()
dict(iterable)
list(iterable)
tuple(iterable)元组
set(iterable)
创建⼀个⽆序不重复元素的集合
complex（）
复数
enumerate()
将字符串或序列⽣成序列对应元组
第五届 系统函数
id()
help()
type()
input()
open()
print()
eval()
将字符串作为代码运⾏，较多与input结合
第⼋章 模块
a
⾃定义模块
调⽤时候需要先放⼊路径，然后import name.然后调⽤ moto.moto(cycle) # coding: utf-8
#name:moto
# In[ ]:
import time
import random
def moto(cycle):
tik = time.time()
count=0
cycle=2**10
x_inp=[]
y_inp=[]
x_out=[]
y_out=[]
#循环
for i in range(cycle):
#⽣成⼀个随机点
x,y=random.random(),random.random()
#判断是否在圆内
if x**2+y**2<1:
count+=1
x_inp.append(x)
y_inp.append(y)
else:
x_out.append(x)
y_out.append(y)
tok= time.time()
pi = 4*count/cycle
print(pi)
print(tok-tik)
⾸先查看路径
import sys
sys.path
路径的优先级是从上到下的，最上⾯的空是设置的⼯作路径
将.py⽂件放⼊⼯作⽬录
import 模块
import语句
包的管理
anaconda的直接使⽤conda命令即可。

管理员权限下打开cmd运⾏命令。

安装
conda install packagename
更新
conda update-all
导⼊⾃⼰编写的内容
赌徒必输练习
赌徒必输理论
已知⼀赌徒，使⽤加倍加注法进⾏押注。

假设该赌徒的胜率为50% 资本为N，尝试证明该赌徒最后必会输光。

加倍押注指的是，以⼀单位（假设此处为1元）作为第⼀场的押注，如果赢了，继续以⼀元押注，如果输了则以2元押注，2元押注如果输了则继续翻倍，直到赢。

赢了后则再从⼀元开始押注。

import random
import matplotlib.pyplot as plt#画图的包，as后⾯是别名，⽅便调⽤
%matplotlib inline
def never_lose(dollar,cycle,d=0.5):
# 设定⼀个资⾦曲线
history = [dollar]
# 初始化赌资倍数
times = 0
# 循环
for i in range(cycle):
# 确定压多少
money=2**times
# if history[-1]>money:
# pool = money
# else:
# pool = history[-1]
pool = money if history[-1]>money else history[-1]
# 开盘，胜率050%，
flag = random.random()
# 计算赌资
win = (1if flag > d else-1)*pool
history.append(history[-1]+win)
# 重新调整下赌资倍数
times = 0if win>0else (times+1)
# 赌资为0，停⽌循环
if history[-1]<=0:
print("经过{}循环，输光了还剩下{}钱".format(i,history[-1]))
break
#循环结束，计算赌资
print("经过{}循环，没输光，还剩下{}钱".format(len(history)-1,history[-1]))
plt.plot(history)
第九章 IO操作
IO表⽰input/output,也就是输⼊和输出
查看⽂件编码
为了⽂件的打开关闭更⽅便，也可以使⽤with语句来⾃动帮我们调⽤close()⽅法。

import chardet
#参数rb为使⽤⼆进制打开
with open("bikes.csv","rb") as f:#相当于try。

finally f.close(),关闭⽂件
data=f.read()
print(chardet.detect(data))
#确认编码打开⽂件
f = open("bikes.csv",encoding= 'ISO-8859-1')
f = open("bikes.csv",encoding= 'ISO-8859-1')
f.readlines()
f.close()
操作⽂件和⽬录
import os
for x,y,z in os.walk(r"D:\python_workspace"):
print(x)#返回⽂件夹内⽂件夹名称
print(y)#返回⽬录内⽂件名称
print(z)#返回⽂件夹内⽂件名称
第⼗章 ⽇期和时间
第⼗⼀章 *类和⾯向对象
python⾯向对象
1. 真实世界中的对象
函数可以把⼀些代码收集到能够反复使⽤的单元中，列表可以收集变量，对象则让这种收集的思想更向前迈进⼀步。

对象可以把函数和数据收集在⼀起。

什么是对象？
对象是对现实事物的抽象，拿球举个例⼦，可以操作⼀个球，⽐如捡球、抛球、踢球或者充⽓。

我们把这些操作称为动作。

还可以通过指出球的颜⾊、⼤⼩和重量来描述⼀个球。

这些就是球的属性。

真实世界的真实对象包括两个⽅⾯。

可以对它们做什么（动作）。

如果描述（属性或特征）。

2. python中的对象
在python中，⼀个对象的特征成为属性，动作称为⽅法。

如果要建⽴⼀个球python版本或者模型，球就是⼀个对象，它有属性和⽅法。

球的属性可能包括球的颜⾊、球的⼤⼩、球的重量
球的⽅法包括kick、throw、inflate等操作
什么是属性
属性就是你所知道的关于球的所有⽅⾯。

球的属性就是⼀些信息
什么是⽅法
⽅法就是可以对对象做的操作，它们是⼀些代码块，可以调⽤这些代码块来完成某个⼯作。

其实，⽅法就是包含在对象中的函数。

函数能做到的，⽅法都可以做到，包括传递参数和返回值。

3. 创建对象
python中创建对象包括两步。

第⼀步是定义对象看上去什么样，会做点什么，也就是它的属性和⽅法。

但是创建这个描述并不会真正创建⼀个对象。

这有点像⼀个房⼦的蓝图。

蓝图可以告诉你房⼦看上去怎么样，但是蓝图本⾝并不是⼀个房⼦。

你不可能住在⼀个蓝图⾥。

只能⽤它来建造真正的房⼦。

实际上，可以使⽤蓝图盖很多的房⼦。

在python中，对象的描述或蓝图称为⼀个类（class）。

第⼆步是使⽤类来建⽴⼀个真正的对象。

这个对象称为这个类的⼀个实例（instance）
创建⼀个简单的Ball类
class Ball:
def bounce(self):
if self.direction == "down":
self.direction = "up"
创建⼀个对象实例
类定义并不是⼀个对象，这只是蓝图，现在来盖真正的房⼦。

上⾯创建的类中，球还没有任何属性，所以给它提供⼀些属性，这是为对象定义属性的⼀种⽅法
class Ball:
def bounce(self):
if self.direction == "down":
self.direction = "up"
myBall = Ball()
myBall.direction = "down"
myBall.color = "red"
myBall.size = "small"
print("I just created a ball.")
print("My ball is",myBall.size)
print("My ball is",myBall.color)
print("My ball's direction is",myBall.direction)
myBall.bounce()
print("Now the ball's direction is",myBall.direction)
I just created a ball.
My ball is small
My ball is red
My ball's direction is down
Now the ball's direction is up
4. 初始化对象
创建球对象时，并没有在size、color或direction中填⼊任何内容。

必须在创建对象之后填充这些内容。

不过有⼀种⽅法可以在创建对象时设置属性。

这称为初始化对象。

初始化表⽰“开始时做好准备”。

在软件中对某个东西初始化时，就是把它设置成⼀种我们希望的状态或条件，以备使⽤。

创建类定义时，可以定义⼀个特定的⽅法，名为__init__()，只要创建这个类的⼀个新实例，就会运⾏这个⽅法。

可以向__init__()⽅法传递参数，这样创建实例时就会把属性设置为你希望的值。

class Ball:
def__init__(self,color,size,direction):
self.color = color
self.size = size
self.direction = direction
def bounce(self):
if self.direction == "down":
self.direction = "up"
myBall = Ball("red","small","down")
print("I just created a ball.")
print("My ball is",myBall.size)
print("My ball is",myBall.color)
print("My ball's direction is",myBall.direction)
myBall.bounce()
print("Now the ball's direction is",myBall.direction)
I just created a ball.
My ball is small
My ball is red
My ball's direction is down
Now the ball's direction is up
5 . “魔法”⽅法：str()
myBall
<__main__.Ball at 0x16a0a0cdf60>
要改变这个显⽰，需要加⼊⼀个__str__()⽅法，让它返回你真正想打印的内容。

这样⼀来，每次使⽤myBall时，它就会显⽰你想要的东西，这就是python中的⼀个“魔法”xxxx()类⽅法！。