参与拿奖：本文已参与「新人创作礼」活动，一起开启掘金创作之路
1.Python环境搭建
1.1 下载Python和PyCharm
1.2 Python3.7+Pycharm环境配置
下载好Python的版本后，包括以下四个文件
首先在高级设置中修改环境变量，将安装的Python文件目录下的python.exe添加到环境变量中，如下图所示：
然后打开cmd，使用python命令检验环境变量是否修改成功
接着是配置PyCharm，按照下图方式配置好就可以了
2.列表
2.1 列表的使用
my_list=[] #创建空列表
my1_list=[1,2] #创建带值的列表
my2_list=list((1,2))
my3_list=list(range(1,10,2))
my4_list=list('hello') #使用list函数将元组，字符串，range对象转换为列表
my1_list=my1_list+[3] #向列表添加元素
my1_list.append(4) #向列表添加元素
my1_list.remove(1) #删除列表中的元素1
my1_list.extend([5,6]) #在列表后添加迭代对象的所有元素
my1_list.insert(3,6) #在列表下标为3的位置插入元素6
my1_list=my1list*3 #在列表末尾添加两遍列表原有元素，复制的元素地址与其复制对象地址一一对应
mylist1=[[2,3]]
mylist1=mylist1*2=[[2,3],[2,3]]
mylist1[0][0]=1<=>mylist1=[[1,3],[1,3]]
my1_list.index(2) #获取元素2的下标
my1_list.count(2) #计算元素2出现的次数
6 in my1_list # in关键字判断元素6是否存在与列表之中
切片操作：适用于列表，元组，字符串，range对象等类型，表示方式是两个冒号分隔的三个数字来完成，第一个数字表示初始位置（默认为0）；第二个数字表示切片截至（但不包含）位置（默认为列表长度）；第三个数字表示切片的步长，步长省略时可以顺便省略最后一个冒号。
my_list=[1,2,3]
my_list[::-1]<=>[3,2,1]
my_list[::2]<=>[1,3]
my_list[1:3:1]<=>[2,3]
my_list[100:]<=>[]
my_list[len(my_list):]=[4]<=>my_list=[1,2,3,4] #通过切片改变列表
#通过is关键字和地址来判断切片的复制类型
my1_list=[1,2]
my2_list=my1_list[::] #浅复制
my3_list=my1_list #深复制
my2_list==my1_list<=>True
my2_list is my1_list<=>False
id(my2_list)==id(my1_list)<==>False
列表排序：
mylist=[1,3,5]
import random
mylist1=random.shuffle(mylist) #打乱顺序
mylist1.sort() #默认升序排序
mylist1.sort(reverse=True) #降序排序
mylist.sort(key=lambda x:len(str(x))) #自定义排序
sorted(mylist1) #使用内置函数sorted排序
sorted(mylist1,reverse=True) #降序排序
mylist.reverse() #逆序
mylist3=reversed(mylist) #逆序
常用内置函数：
①cmp(序列1，序列2)：比较两个序列的大小，大于返回1，==返回0，小于返回-1//Python3.x不再支持
②max(列表)/min(列表)/sum(列表)：返回列表的最大值，最小值以及求和
③zip(列表1，列表2，···)：将多个列表或元组对应位置的元素组合为元组，返回包含这些元组的zip对象
list=[1,2]
list1=[3,4]
list2=zip(list,list1)
list3=list(list2)<=>[(1,2),(3,4)] #Python3.x版本
④enumerate(列表)：枚举列表、元组或其他可迭代对象的元素，返回枚举对象，枚举对象中每个元素是包含下标和元素值的元组，该函数对字符串和字典同样有效。
list=[1,2]
for i in enumerate(list):
print(i)
>>>(0,1)
>>>(1,2)
for index ,ch in enumerate('STDIO')
print((index,ch),end=' ')
>>>(0,'S'),(1,'T'),(2,'D'),(3,'I'),(4,'O')
2.2 *列表推导式：使用非常简单的方式来快速生成满足特定需求的列表，代码具有非常强的可读性
1)普通的使用
list=[x*x for x in range(10)] #方法一
<=>list=[]
for x in range(10):
list.append(x*x) #方法二
2)使用列表推导式来实现嵌套列表的平铺
list=[[1],[2],[3]]
[num for elem in list for num in elem]
>>>[1,2,3]
3)过滤不符合条件的元素
import os
[filename for filename in os.listdir('.') if filename.endswith('.py')] #列出当前文件夹下的所有Python源文件
list=[1,2,3]
[i for i in list if i>2]
>>>[3]
4)使用多重循环，实现多序列元素的任意组合
[(x,y) for x in range(2) for y in range(2)]
>>>[(0,0),(0,1),(1,0),(1,1)]
5)实现矩阵转置
list=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
[[row[i] for row in list] for i in range(4)]
>>>[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]
list(zip(* list))
>>>[(1,5,9),(2,6,10),(3,7,11),(4,8,12)] #通过zip函数实现矩阵的转置
6)可以使用函数
def f(v):
if v %2==0:
v=v**2
else:
v=v+1
return v
print([f(v) for v in [2,3,4,-1] if v>0])
>>>[4,4,16]
print([v**2 if v%2==0 else v=v+1 for v in [2,3,4,-1] if v>0])
>>>[4,4,16]
7)支持文件对象迭代
fp =open('1.txt')
print([line for line in fp])
>>>#打印出1.txt中文件内容
fp.close()
8)生成素数
n=input('输入一个大于2的数：')
[p for p in range(2,n) if 0 not in [p%d for d in range(2,int(sqrt(p))+1)]]
>>>3
>>> [2,3]
3.元组
元组与列表类似，但元组属于不可变序列；元组一旦创建，用任何方法都不能修改其元素的值，也无法为元组增加和删除元素，如果需要修改只能通过重新创建元组来完成，元组中所有元素放在"("和“)"之间，列表是放在“["和"]”之中
3.1 元组的创建和删除
my_tuple=('a',) #当元组只有一个元素时需要加一个“,”在后面
my1_tuple=() #空元组
my_list=[1,2] #创建一个列表
my2_tuple=tuple(my_list) #将列表转换为元组
my3_tuple=tuple() #空元组
del my_tuple #只能通过del删除整个元组，不能单独删除元组某个元素
3.2 序列解包
序列解包可以大大减少代码的输入量，可以用于元组，列表和字典
>>>x,y,z=1,2,3
>>>print(x,y,z)
>>>1,2,3 #使用序列解包对多个变量同时赋值
a=[1,2,3]
b,c,d=a #使用序列解包将列表元素赋给多个变量
s={'a':1,'b':2,'c':3}
b,c,d=s.items() #对字典的“键-值对”操作需要使用items()函数
>>>b
>>>('c':3)
m,n,v=s
>>>m
>>>'c'
j,k,l=s.values() #对字典的值操作时需要使用values()函数
>>>j
>>>1
keys=['a','b','c']
values=[1,2,3]
for k,v in zip(keys,values):
print(k,v)
>>>a 1
>>>b 2
>>>c 3 #使用序列解包可以同时遍历多个序列
在调用函数时，在实参前面加一个星号(*)也可以进行序列解包，从而实现序列中的元素值依次传递给相同数量的形参
print(*[1],*[2]) #调用函数时参数序列解包
>>>1 2
def dem(a,b,c,d):
print(a,b,c,d)
dem(**{'a':1,'c':3},**{'b':2,'d':4})
>>>1 2 3 4
*range(4),4
>>>(0,1,2,3,4)
3.3 生成器推导式
生成器推导式的结果是一个生成器对象，而不是列表，也不是元组。使用生成器对象的元素时，可以根据需要将其转换为列表或元组，也可以使用生成器对象的next方法（Python2.x）或__next__方法（Python3.x）进行遍历，或者直接将其作为迭代器对象来使用。当所有元素访问结束后，如果需要重新访问其中的元素，都必须重新建立该生成器对象。
g=((i+2)**2 for i in range(3))
>>>g #不会输出g的值
>>>tuple(g) #转换为元组
>>>(4,9,16)
>>>tuple(g)
>>>() #元素已经遍历结束
g=((i+2)**2 for i in range(3)) #重新创建生成器对象
list(g) #转化为列表
>>>[4,,9,16]
g.next()
4 #Python2.x中的单步迭代
g.__next__()
4 #Python3.x中的单步迭代
g=((i+2)**2 for i in range(3))
for i in g: #直接循环迭代
print(i)
4 9 16 #Python2.x中输出格式
print(i,end=' ')
4 6 9 #Python3.x输出格式
4.字典
字典是”键-值对“的无序可变序列，字典中的每个元素包含两部分：“键（key）”和“值（value）”,键必须为不可变数据，且不允许重复（值允许重复）。可以使用内置函数globals()返回和查看包含当前作用域内所有全局变量和值的字典，使用内置函数locals()返回包含当前作用域内所有局部变量和值的字典。
4.1 字典的创建和删除
dict={'a':2,'b':3} #字典初始化
keys=['a','b','c']
values=['1','2','3']
dictionary=dict(zip(keys,values)) #使用内置函数dict()通过已有数据快速创建字典
x=dict() #空字典
x={} #空字典
d=dict(name='Dog',age='27') #使用内置函数根据“键-值对”来创建字典
>>>d
>>>{'age':27,'name':Dog} #初始化字典对象
d1=dict.fromkeys(['name','age','sex']) #创建“值”为空的字典
del d1 #删除整个字典
4.2 字典元素的读取
d=dict(name='Dog',age='27')
d['name'] #通过键来读取元素
d.get('name') #通过get()函数来读取指定键的值
d.get('address','None') #当指定键不存在时可以指定输出值,第二个参数
for item in d.items():
print(item)
>>>('age':27)
>>>('name':Dog) #通过字典对象的items()方法可以返回字典的“键-值对”列表
for key in d.keys():
print(key)
>>>age
>>>name #通过字典对象的keys()方法可以返回字典的“键”列表
for key,value in d.items():
print(key,value)
>>>age 27
>>>name Dog
4.3 字典元素的添加与修改
d=dict(name='Dog',age='27')
d['name']=QinHsiu #直接修改指定值
d['address']=CQ #直接添加“键-值对”
d1={'a':1}
d.update(d1) #通过update()函数将另外一个字典中的所有元素添加到指定的字典对象当中来，如果出现键值重复时以另外一个字典的值为准，类似与修改
#通过del命令来删除指定键值或者使用clear()方法来删除字典中所有元素，也可以通过pop()函数来删除并返回指定“键”的元素，或者使用字典对象的popitem()方法删除并返回字典中的一个元素
4.4 字典应用之统计字符串中字符出现个数
import string
x=input('请输入字符串：')
a=string.ascii_letters+string.digits+string.punctuation #将a初始化为所有字符，即“键”
z=' '.join(x)
d=dict()
for ch in z:
d[ch]=d.get(ch,0)+1 #方法一
import string
x=input('请输入字符串：')
a=string.ascii_letters+string.digits+string.punctuation #将a初始化为所有字符，即“键”
z=' '.join(x)
from collects import defaultdict
from collects import Counter #使用Counter可以快速实现上述功能
frequences=defaultdict(int)
for item in z:
frequences[item]+=1
#frequences.items()
frquences=Counter(z)
frequences.items()
frequences.most_common(1) #打印出出现次数最多的字符
{i:str(i) for i in range(2)}
>>>{'0':0,'1':1} #字典推导公式快速生成字典
a=['a','b']
b=['1','2']
{a:b for a,b in zip(a,b)}
>>>{'a':1,'b':2}
import collections
x=collections.OrderedDict() #有序字典
>>>x['a']=3
>>>x['c']=8
>>>x['b']=5
>>>x
OrderedDict([('a',3),('b',5),('c',8)])
5.集合：
集合为无序可变序列，与字典一样界定符使用大括号表示，但是同一个集合之间的元素不能重复。
a={1,2} #集合初始化
a.add(7) #添加元素
b=[3,4] #创建列表
c=set(b) #通过set()函数将其他可迭代对象转换为集合
x=set() #空集合
a.pop() #弹出并删除第一个元素，pop()函数没有参数
a.remove(2) #移除指定元素
5.1 集合操作
a={1,2}
b={2,3}
a|b #通过|字符求并集
a.union(b) #通过函数union()求并集
a&b #通过&字符求交集
a.intersection(b) #通过intersection()求交集
a.difference(b) #通过difference()求差集
a.symmetric_difference(b) #通过symmetric_difference()求对称差
a<b #比较集合大小
a.issubset(b) #通过issubset()测试其是否为子集c
c={0,1,2,1,3}
d=set(c) #可以通过集合的set()函数快速去重
5.2 集合的应用
import random
import time
def RS(n,s,e): #n表示数据个数，s表示开始位置，e表示结束位置
data=[]
m=0 #m用来记录存取的个数
while True:
element=random.randint(s,e)
if element not in data:
data.append(element)
m+=1
if m==n-1:
break
return data #方法一
def RS1(n,s,e):
data=[]
while True:
element=random.randint(s,e)
if element not in data:
data.append(element)
if len(data)==n:
break
return data #方法二
def RS2(n,s,e):
data=set()
while True:
data.add(random.randint(s,e))
if len(data)==n:
break
return data #方法三
s=time.time()
s1=time.time()
s2=time.time()
for i in range(10000):
RS(50,1,100)
RS1(50,1,100)
RS2(50,1,100)
print('Time used:',time.time()-s)
print('Time used:',time.time()-s1)
print('Time used:',time.time()-s2)
5.3 集合推导公式
{x.strip() for x in {'h','b'}}
>>>{'h','b'}
