Python学习

Python学习：

 

 

 

1.部分初级函数

1.1打印函数：

print（变量）

print（"任意话"）

 

打印后不换行：

print（变量,end=''）

打印出变量后加的东西在''中间例如空格：

print（i,end=' '）

 

 

1.2输入函数：

input（）

input（''）'里面可以加上想说的话'

例输入一个数赋值到i上：

i=input（）

i=input（'给我一个数'）

i=str（input（''给个数吧爸爸））

 

 

结束时不直接关闭：

input（）

 

1.3断言函数

assert

assert 错误  ＝＝系统报错

例： assert 3＞4  报错

 

（转义字符串）：

打印带"的话："前加上\

print（"let\"s go!"）

打印带\n的： \前加\

print（"c:\\now"）

 

（原始字符串）：

对多个需要转义的：""前加上r

print（r"\a\b\c\"）

 

一次打印多行：（用6个"）

print（"""好

多

行"""）

 

 

 

 

2.数据类型：

int（）：整形  %d（整数）

float（）：浮点型%f（有小数点的数(6位)）   这里%.1f就表示保留到小数点后一位

str（）:字符串 %c(单个) %s(整个)                  这里%6.f就表示这个数最小占6个格子

list[]：列表                                    这里%+/-6f就表示这个数是靠左对齐（-）还是靠右（+）

tuple（）元组

set{}集合

dict{:}字典

type（名称）查看名称的数据类型

e记法：

15000000=15e6

0.00000023=23e-8

%c也可以表示ASCII码（例如a的ASCII吗为97）

'%c' % 97 == a

'%c %c,%c'%(97,98,99)==a b,c(具体可找.format)

 

2.1强行转换：

a=int（43）

a=int（b）把b强行转换成int然后给a

b=float（520.0）

c=str（124）

 

2.2获得字符类型函数：

type（变量）

 

a=str（1121）

type（a）   [结果为<class str>]

 

2.3判断数据类型函数：

isinstance（变量,数据类型）

[结果为ture false]

 

isinstance（a,str）

 

 

 

 

3.操作符

3.1比较操作符：

>＝  大于等于

＜=  小于等于

＝＝  等于

！=  不等于

 

Tab:缩进

大量缩进：选中要缩进点代码后安Tab

 

 

 

3.2算数操作符：

＋－（正负） 一元操作符

＋加

－减

*乘

/除

**幂运算

//地板除  （去除小数点后面的数）

%求余

3**2＝9

5//4＝1

5%2＝1

优先级：

-a  ＞  （）  ＞  */  ＞  ＋－  ＞  and

＞＜==     ＞     and or

**的优先级比左边高比右边低

特殊：

a＋＋     ＝    a＝a＋1

a－＝b   ＝    a＝a－b

 

 

3.3逻辑操作符：

and 并语句 （a＜b）and（a＜c）

or   或语句    （a==b）or（c＜＝a）

 

3.4随机函数：

random

randint（a,b）输入一个a到b的数

使用方法：

a=random.randint（a,b）

 

使用前要先加上：

import random

目的是将random函数添加进去

全文开头加一次就好

 

 

 

 

 

4.if/while语句

4.1if条件函数：

if 条件：

    表达式1

else：

    表达式2

 

if x＜y:

    small＝x

else:

    small＝y

＝＝

small＝x if x＜y else y （三元操作符）

 

if 条件1：

    表达式1

else：

    if 条件2：

        表达式2

    else：

        表达式3

 

if 条件1：

    表达式1

elif 条件2：   （else if）

    表达式2

elif 条件3：

    表达式3

 

 

 

 

 

 

4.2循环语句：

 

while 循环函数：

while 条件：

    循环体语句

 

i＝0

while i＜=3:

    i＋＋

 

while 条件：

    循环体语句（True时执行）

else :

循环体语句（False)(但只执行一次)(也就比加if方便一点)

 

else里面的语句执行的条件是里面的代码不中途跳出

i=1

while i<5:

    print(i)

    i+=1

    if i==3:

        break

else :

print('马老师发生什么事了')-----------------------------------<=1

中途退出,else语句不会被执行    2

 

无限循环：

Ctrl + C

按下快捷键可以快速停止（而不是把Python关掉）

 

 

 

4.3for循环：

 

for 目标 in 变量

    循环体

 

for 目标 in 数组

favourite = fishc

for i in favourite:

    print（i,end=' '）

 

 

 

 

 

 

 

4.3.1for循环小伙伴：

range（）

range（[start,]stop[,step=1]）

这个start默认从0开始 step默认为1

step指每次循环增加的长度

但stop的那个数是不会出现的

例如：

range（1,5）==1 2 3 4

range（1,8,2）==1 3 5 7

 

 

 

 

 

4.4break/continue语句：

break：结束上一个循环

continue:结束这一次的循环直接进行下一次的循环

 

例：break：

for i in range（1,10）:

    if i%2!=0:

        print（i）

        break

    i＋=2

    print（i）

 

这里当i为奇数时，会执行  print（i）和

break break会直接将这个for结束掉转而执行后面的语句

 

例：continue：

for i in range（1,10）:

    if i%2!=0:

        print（i）

        continue

    i＋=2

    print（i）

这里当i为奇数时，会执行  print（i）和

continue continue会直接将这个i对应的

i＋=2和print（i）结束掉转而运行下一个i

也就是说for循环没有结束

    

 

 

 

 

 

列举函数：

list（数组）

（然后会把数组里的内容列举出来）

 

mumber=[1,3,6,8]

list（member）==1 3 6 8

 

list（range（1,4））=1 2 3

 

 

 

 

 

 

 

 

 

 

 

 

5.序列：

这里序列来简单总结下面的列表 元组 集合 字典 字符串

列表 list

元组 tuple

集合

字典 dist

字符串 str

帮助函数：

help(list)列出列表的帮助函数

 

5.1测量长度函数：

len(序列名称)

member = [1,2,3,4,5,6]

ber = (1,2,3)

len(menber)==6

len(ber)==3

 

5.2测出最大最小值

max(序列名)

min(序列名)

member = [1,5,-9,999]

mem={1,5,8,9,5,3,1,77}

max(member)==999

min(mem)==1

 

5.3算总和函数

sum（序列名[，数]）

member = (1,2,3,4,5,6)

sum(member)==21

sum(member,8)==29

 

5.4排序函数：

sorted(序列名)（顺序排列）

reversed(序列名)(逆序排列)

member=[6,9,-99,100]

sorted(member)==[-99,6,9,100]

reversed(member)==<一个迭代器对象>

这个迭代器对象可以转化为list(列表)

list(reversed(member))==[100,9,6,-99]

 

5.5列举序列函数：

enumerate(序列名)                      enumerate 列举 枚举

enumerate函数会让列表的每个数变成（地标，数）的形式

number = [6,3,9]

enumerate(number)==<和reversed类似的迭代器对象>

list(enumerate(number))==[(0,6),(1,3),(2,9)]

 

5.6打包压缩函数：

zip(列表1，列表2)

a=[7,8,9,10,11,12]

b=[1,2,3,4]

zip(a,b)==<一个迭代器对象>

list(zip(a,b))==[(7,1),(8,2),(9,3),(10,4)]

 

5.7读取地址函数

id(序列名称)

 

 

 

 

 

 

 

 

 

 

 

 

 

6.列表：

列表 = [列表内容,列表内容]

列表里可以加任何数据类型的东西

甚至可以加列表

创建空列表a=[]

mumber=[1,3,6,8]

mum = ['小甲鱼','小布丁']

ber=[1,2,'小金鱼',[1,2,3]]

 

列表[数字] ：表示列表中第数字－1个东西

列表[－1]：表示列表中倒数第一个东西

列表[a:b]： 表示列表中第a＋1到b－1的东西

 

 

6.1添加项目与修改项目

修改就仅仅将列表的那个元素改掉就好

member[0]=1

member中的第1个元素就变成了1

 

append（）添加1个元素：

列表名称.append（添加内容）

member.append（1）

1就会变成member的最后一项

也可以直接member＋=[元素]

 

extend（[列表]）添加多个元素：

列表名称.extend（[添加列表]）

member.extend（[1,2,3]）

1,2,3会分别加入member

也可以直接member＋=[列表]

 

insert（位置，元素）添加元素到特定位置

member.insert（2,'a'）

 

6.2删除元素：

列表名称.remove（元素）

不需要知道元素所在位置

member.remove（2）

第一个2元素就被删除了

 

列表名称.pop（位置）

删除知道位置的元素

member.pop（2）

 

del 列表名称[要删除元素的位置]删除元素

del member[2]

member中的第3个元素就被删除了

 

6.3简单拷贝：

列表名称[a:b]

member=[1,2,3,4]

member[1:3]==[2,3]

member[:]==[1,2,3,4]

 

列出list帮助函数：

help（list）

 

其他转换为列表：

列表名=list(其他的名)

 

6.4deque函数：

使用前先加上：

from collections import deque

从collections 文件夹中找到deque函数并加上

deque是一个类似list的东西 但你用type看类型时会发现这是deque 类型

用deque语法前要先将list转化为deque：

from collection import deque

number = deque(number)

number = deque([1,2,3,4,5])

 

从左边添加：

num.append(‘wuhu’)     <-deque([1,2,3,4,5,’wuhu’])

num.append([7,8,9])     <-deque([1,2,3,4,[7,8,9]])

num.extend([7,8,9])   <-deque([1,2,3,4,7,8,9])

num.appendleft(‘wuhu’)  <-deque([‘wuhu’,1,2,3,4,5])

num.extend([7,8,9])      <-deque([9,8,7,1,2,3,4,5])

 

顺序旋转排列:

num.rotate(1)          <-deque([5,1,2,3,4])

num.rotate(-1)          <-deque([2,3,4,5,1])

 

弹出元素:

num.pop()            <- 5

num.popleft()         <- 1

 

6.5列表推导式

用for函数把列表进行推导

也就是用起来更快的for循环

[带着变量的式子 for 变量名 列表名]    <-注意这里出来是一个列表 需要加上[]

num=[1,2,3,4]

[i*i for i in num] ---------<-[1,4,9,16]

[[i*i,i+i] for i in num]----<-[[1,2],[4,4],[9,6],[16,8]]

 

高级一些：

number=[‘   a’,’   b’,’c’]

[i.strip() for i in number]-------<=[‘a’,’b’,’c’]

 

用if过滤:

number =[1,2,3,4,5]

[i*i for i in number if i>1]--------<=[4, 9, 16, 25]

 

内嵌：

num=[1,2,3]

ber=[4,5,6]

[i*j for i in num for j in ber]---------<=[4, 5, 6, 8, 10, 12, 12, 15, 18]

[num[i]*ber[i] for i in range(len(num))]-----<=[4, 10, 18]

 

 

 

 

 

 

 

 

7.元组：

7.1元组个人理解

就是无法删除或改变元素的列表

元组用（）表示

member=（1,2,'asd'）

mem=（4,）

ber='a','b','c'（不需要括号也可以）

abc=（）（创建空元组）

 

访问时元组与列表一样

member=（1,2,3,4）

member[2]=3

 

7.2添加与删除元组：

添加：

member＋＝1

member＋=（'a','b'）

删除：

del member

 

7.3元组的内置函数：

member=（1,2,3,4）

返回元组中的最大值：

max（元组名）

max（member）

 

返回元组中的最小值

min（元组名）

min（member）

 

7.4将列表转换成元组：

tuple（列表名）

member[1,2,3]

mem=tuple（member）

 

 

 

 

 

 

 

 

 

 

 

 

8.集合：

个人理解：

集合就是不会有重复值的列表

且元素只会以元素的形式存在

8.1创建集合：

列表名={}或列表名=set（）

member={1,2,3,4,5}

mem=set（'a','b'）

ber=set（）

 

8.2添加集合元素:

集合名称.add（添加一个元素）

s.add（）只能一次添加一个元素

member.add（'a'）

 

集合名称.update（多个元素）

update可以加多个元素

例{1,2,3} （'a','b'） ['q','w'].['e','r']

member.update（1,2,3）

 

8.3移出元素：

s.remove（）

集合名称.remove（要移出的元素）

member={1,2,3}

member.remove（1）

如果要移出的元素不存在于集合中会报错

 

s.discard（）

集合名称.discard（要移出的元素）

member={1,2,3}

member.discard（1）

如果要移出的元素不存在于集合中不会报错

 

随机移除集合元素函数

s.pop（）

元素=集合名称.pop（）

member={1,2,3}

a=member.pop（）

a就可能成为1或2或3

 

计算集合元素个数：

len（）

len（集合名称）

member={'a','b'}

len（member）=2

 

清空集合：

s.clear（）

集合名称.clear（）

 

8.4判断集合中元素存在与否函数

元素 in 集合名称

member={'a','b'}

'a' in member

Ture

'c' not in number------------False

 

8.5集合的内置函数：（a,b为集合）

－ | & ^

a－b：集合a中有但集合b中没有的元素

a|b：集合a或集合b中有的元素

a&b:集合a,b中都有的元素

a^b:不同时包含与a,b的元素

a^b==a－b ＋ b－a

 

8.6将集合变成不可变化的
set = frozenset(可迭代对象)

set1= frozenset([1,2,3,4,5])

try:

set1.add(6)

except:

print('error')-------------------------------error

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

9.字典：

个人理解：

字典是用一个元素对应另一个元素

然后这两个元素算作字典里的1个元素

这样说字典更像是二维的列表

 

9.1创建字典：

字典名={x1:y1,x2:y2,x3:y3}

x为键 y为值

其中x1与y1对应 x2与y2对应

member={'a':1,'b':2}

 

将二维列表转化为字典：

dict1=[[‘f’,70],[‘i’,105],[‘s’,115],[‘h’,104],[‘c’,67]]

dict2=dict(dict1)------------------------------------------------<={'f': 70, 'i': 105, 's': 115, 'h': 104, 'c': 67}

 

将二维元组转化为字典

dict1=dict((('f',70),('i',105),('s',115),('h',104),('c',67)))

 

9.2访问字典

字典名[key数]

member={'a':1,'b':2}

member['a']     =     1

没有访问的键会报错

 

不会报错的访问：

字典名称.get(key[,没有返还的值])

dict1={1:'a',2:'b'}

dict1.get(3)------------------------------<=None

dict1.get(3,'没有呀')------------------<=没有呀

 

下例子

dict1=dict.fromkeys((1,2),('芜湖'))

访问指点的键:

字典名.keys()

for i in dict1.keys():

print(i)------------------------------<=1

  2

访问字典的值

字典名.values()

for i in dict1.values():

print(i)----------------------------<=芜湖

   芜湖

访问整个项
字典名.items()

for i in dict.items():

print(i)----------------------------<=   (1,芜湖)

(2，芜湖)

9.3添加/修改 键/值

字典名称[键]：值

键已有则会改变原来的值

键没有则会添加键与值

member['a']:1

 

添加一个键/值

dict.setdefault(key[,value])

没有value则为None

dict1={'a':1,'b':2}

dict1.setdefault('c',3)

dict1----------------------------------{'a':1,'b':2,'c':3}

 

增加多个键/值

dict.update(dict_2)

这个可以将另一个字典更新到一个字典里 从而达到添加多个键/值的效果

a={'a':1,'b':2}

b={'c':3,'d':4}

a.update(b)

a -------------------------------<={'a':1,'b':2,'c':3,'d':4}

 

也可以用.fromkeys(可迭代对象)创建一个只有键的字典

dist.fromkeys(可迭代对象)

number=(1,2,3,4,5)

dist1=dist.fromkeys(number)

print(dist1)------------------------<={1:none,2:none,3:none,4:none,5:none}

dist1.fromkeys((1,2,3),('a','b','c'))---<={1:('a','b','c'),2:('a','b','c'),3:('a','b','c')}

 

删除字典中的一个值

字典名.pop([key])

不加键名会随机删除一个键和他对于的值 并返回值

加上键则会删除固定的键

dict1 = {'a':1,'b':2}

dict1.pop('a')-----------------<=1

 

字典名.popitem([key])

这个和.pop很像 但返回的是整个键和值

dict1={'a':1,'b':2}

dict1.popitem('b')-----------<=('b',2)

 

9.4删除字典:

del 字典名[键名] （删除一个键）

del member['a']

 

字典名.clear（）

清空字典

member.clear（）

 

尽量不要用member={}

 

del 字典名

删除字典

 

9.5检查函数：

in/not in

dict1={'a':1,'b':2}

'a' in dict1---------------------------<=True

'c' not in dict1----------------------<=False

 

9.6浅拷贝函数:

字典名.copy()

可以将一个字典的全部浅拷贝到另一个中

a={'a':1,'b':2}

b=a.copy()

b ---------------------------------<={'a':1,'b':2}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

10.字符串：

10.1创建字符串：

字符串名称='字符串内容'

str1='Hello word!'

 

创建多行：

str1='''

多

行

'''

 

10.2访问字符串内容:

字符串名称[地标名]

在创建好字符串后：

str1='Hello world!'

str1[2]=l

str1[2:]=llo world!

 

10.3首字母大写函数：

字符串名称.capitalize()

str1='qweasd'

str1.capitalize()

str1=='Qweasd'

 

10.4所有字符变小写函数：

字符串名称.casefold()

str1='QWEasd'

str1.casefold()

str1==qweasd

 

10.5居中字符串：

字符串名称.center(width)

将这个字符串居中，左右加上点空隙

str1='qweqwe'

str1.center(6+8)=='    qweqwe    '

 

10.6字符串中某字符数量函数：

字符串名称.count（字符[a:b]）

a到b是范围

str1='abcdefjhiiiji'

str1.count('i')==4

 

10.7字符串是否已某字符结束函数：

字符串名称.endswith(字符)

str1='qweqweww'

str1.endswith('ew')==True

str1.endswith('s')==Fulse

 

10.8字符串\t转化为空格函数：

字符串名称.expandtabs(空格数量)  空格数量默认为8

str1='i\tlove\tfishc'

str1.expand() =='i       love    fishc'

 

10.9寻找字符串中是否有某字符函数1：

10.9.1

字符串名称.find(字符)

有则返还第一个地标，否则返还-1（不会产生异常）(从左边开始）

str1='uiouioiou'

str1.find('u')==0

str1.find('y')==-1

 

10.9.2寻找字符串中是否有某字符函数2：

字符串名称.index（字符）

有则返还第一个的地标，没有则报错

str1='ajsdlajd'

str1.index('j')==1

str1.index('q')==报错

 

10.9.3寻找字符串中是否有某字符函数3:

字符串名称.rfind(字符)

str1='as1d3as2das1'

str1.rfind('s')==10

 

 

10.10查找字符串内是否全是数字/字母函数：

字符串名称.isalnum()

member = '123456sdad79'

mem='6a4s6da啊这'

member.isalnum() == True

mem.isalnum() == False

 

10.11查找字符串内是否全为字母/汉字函数：

字符串名称.isalpha()

member='alkjsdkla啊这'

mem='a3s1d35as'

member .isalpha() == True

mem.isalpha() == False

 

10.12查找字符串内是否全为数字函数:

字符串名称.isdigit()

member='56131'

ber = 'as465'

member.isdigit() ==True

ber.isdigit() == False

 

10.13查找字符串中是否全为数字字符函数：

字符串名称.isnumeric()

member='131351123'

ber = 'as6d1a31d'

member.isnumeric() ==True

ber.sinumeric() ==False

 

10.14查找字符串中的字母是否全为小写函数：

字符串名称.islower()

member = '1a1dsaad9a+1+1as+d'

ber = 'AS13dsa3asd+'

member.islower()==True

ber.islower()==False

 

10.15查找字符串中的字母是否全为大写函数：

字符串名称.issuper()

member = 'ASDKJA+544+'

mem = 'ASD6s4ada6sd+'

member.issuper() ==True

mem.issuper()==False

 

10.16查找字符串中是否全为空格函数：

字符串名称.isspace()

member='     '

mem='j lk j l '

member.isspace()

mem.isspace()==False

 

10.17查找字符串是否为标题格式函数（大写开头，其余小写）

字符串名称.title()

str1='Fishc'

str2='FishC'

str1.istitle()==True

str2.istitle()==False

 

10.18字符串字母大写转换为小写函数：

字符串名称.lower（）

str1='ASDAasda'

str1.lower()=='asdaasda'

 

10.19字符串字母大小写转换函数：

字符串名称.swapcase()

str1='ASLDsadjl'

str1.swapcase()=='asldSADJL'

 

10.20字符串去掉左侧空格函数：

字符串名称.lstrip()              strip 脱去衣服

str1='    as4d6a'

str1.lstrip()

str1=='as4d6a'

 

10.21字符串去掉右侧空格函数：

字符串名称.rstrip()

str1='ajslda  '

str1.rstrip()

str1=='ajslda'

 

10.22字符串去掉左右两侧空格函数：

字符串名称.strip([chars])

str1='   asd    '

str1.strip()=='asd'

 

10.23字符串替换函数：

字符串名称.replace(旧的字符，新的，次数)

没有次数默认为9999

替换后原字符串不会改变（半个小时的教训）

str1='abcdefgaaa'

print(str1.replace('a','A',2))==AbcdefgAaa

print(str1)==abcdefgaaa

 

10.24以''分开字符串转列表函数：

字符串名称.split（）默认为空格

str1='abc asd qwe'

str1.split()==['abc','asd','qwe']

str1.split('a')==['','bc ','sd qwe']

 

 

10.25字符串内置函数：

+：字符串相加

str1='hello'

str2='world!'

str1+str2==helloworld!

 

*:重复输出字符串

str1='wuhu'

str1*4==wuhuwuhuwuhuwuhu

 

[]:访问单个字符

str1='wuhu'

str1[2]=='h'

 

[:]:访问多个字符

str1='woshishabi'

str[1:3]=='os'

str[:5]=='woshi'

str[5:]=='shabi'

 

in:判断一个字符是否在字符串中

str1='qweasdzxc'

'e' in str1==True

'b' in str1==False

 

not:判断一个字符是否不再字符串中

str1='qwerty'

'q' not in str1==False

'a' not in str1==True

 

 

 

 

10.26字符串关键字参数函数：

.format（）

'{0}是{1}的爸爸'.format('刘雨琪','郝天')==刘雨琪是郝天的爸爸

前面的{}内加上字标，后面可以在对应的字标位置加上字符串，可以实现字符串自由的连接

也可以将0改为a 但后面也要改掉

'{0}是{b}的爸爸'.format('刘雨琪',b='郝天')==刘雨琪是郝天的爸爸

但这个位置参数（地标）必须在关键字参数之前（'{a}{1}'就不可以）(关键字参数必须是一个小写字母，可以任意)0

这里注意：如果想要在.format函数中打印出{} 必须用{}转义（和print(\\)一个道理 第一个\把第二个\转义了）

例如：'{{0}},,{0}'.format('a')=={0},,a

'{{{0}}},,{1}'.format('a','b')=={a},,b

 

然后就可以用 变量类型 代替字符串了

例如'{0:.1f},,{1:d}'.format(1.32,32)==1.3,,32

'%d + %d = %d'%(4,5,4+5)==4 + 5 = 9

'{:d}+{:d}={:d}'.format(4,5,4+5)==4+5=9

%c也可以表示ASCII码（例如a的ASCII吗为97）

'%c' % 97 == a

'%c %c,%c'%(97,98,99)==a b,c

 

 

 

 

 

11.需要有系统命名函数：

11.1模块

模块是可用代码段的打包

import file

就是打开 file这个文件的函数

也可以自己做一个这样的文件

a=open('text.py','w+')

a.write('def fun1():\n print('我爱lly')')

这样就在text.py中创建了一个叫做fun1()的函数

 

在你的文件中就可以:

import text

fun1-------------------------------------<=我爱lly

 

当你要加入多个函数时 需要用from file import fun

这样从file文件中取出了fun()这个函数

from collections import deque

 

多个的时候可用用*

from file import *

这样file中的所有函数就都被调用了

 

 

11.2 sys

系统命令

直接让系统退出函数:

import sys

sys.exit()

 

在加入import sys后

input()

sys.exit()

input()

在打出这段代码后 你只会输入一次数 第二个input()会因为sys.exit()直接退出而消失

 

设置递归数量（默认为100）

import sys

sys.setrecursionlimit(数量)                  recursion 递归

sys.setrecursionlimit(99999)

 

11.3winsound

发出声音：

import winsound（发出声音要以这个为前提）

winsound.Beep(大小,时间) 时间为毫秒

 

11.4 time

延迟时间：

import time(实现延迟要有这个前提)

time.sleep(时间)时间为秒

 

打印时间：

import time

time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))

 

11.5deque函数：

from collections import

 

从collections 文件夹中找到deque函数并加上

deque是一个类似list的东西 但你用type看类型时会发现这是deque 类型

用deque语法前要先将list转化为deque：

from collection import deque

number = deque(number)

number = deque([1,2,3,4,5])

 

从左边添加：

num.append(‘wuhu’)     <-deque([1,2,3,4,5,’wuhu’])

num.append([7,8,9])     <-deque([1,2,3,4,[7,8,9]])

num.extend([7,8,9])   <-deque([1,2,3,4,7,8,9])

num.appendleft(‘wuhu’)  <-deque([‘wuhu’,1,2,3,4,5])

num.extend([7,8,9])      <-deque([9,8,7,1,2,3,4,5])

 

顺序旋转排列:

num.rotate(1)          <-deque([5,1,2,3,4])

num.rotate(-1)          <-deque([2,3,4,5,1])

 

弹出元素:

num.pop()            <- 5

num.popleft()         <- 1

 

 

11.6 random

随机数函数

import random

randint（a,b）输入一个a到b的数

使用方法：

a=random.randint（a,b）

 

11.7 os

os模块是处理文件的一个关键的东西

其能力要大于文件的代码

import os

 

11.8 os.path

os的一个衍生

import os.path

 

 

 

 

 

 

 

 

 

 

12.迭代器和生成器：

迭代器是Python中非常有意思的一个东西

它只能向后走，不能向前（除非重新开始）

迭代器会从第一个开始访问，直到最后一个

 

12.1创建迭代器函数：

iter(序列名称)

list1=[1,2,3,4]

it =iter(list1) #这样it就会变成一个迭代器 可以用list(it)返还回来

for i in it:

    print(i)==1,2,3,4

 

12.2访问迭代器函数:

next(迭代器名称)

 

list1=[1,2,3,4]

it = iter(list1)

print(next(it))==1

print(next(it))==2

 

当迭代器无法继续走的时候会出现StopIteration错误

在了解这些后可以用错误处理函数来配合迭代器运行：

import sys

list1=[1,2,3,4,5,6,7]

it = iter(list1)

while True:

    try:

        print(next(it))

    except StopIteration:

        sys.exit()

这样组合会更舒服

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

13.函数函数函数！！！！

创建函数：

def 函数名（）：

 

def MyFirstFunction():

    print('这是我创建的第一个函数！')

    print('我表示很鸡冻.......')

    print('现在是21/5/13/22:55')

 

 

 

 

13.1调用函数：

函数名（）

调用时Python会往上寻找

def MyFirstFunction():

    print('这是我创建的第一个函数！')

    print('我表示很鸡冻.......')

    print('现在是21/5/13/22:55')

 

MyFirstFunction()

==这是我创建的第一个函数！

    我表示很鸡冻.......

    现在是21/5/13/22:55

 

没有找到函数会报错

 

 

 

 

13.2含参函数：

def 函数名(参数名1，参数名2，参数名3......)：        

    print(参数名1，参数名2，参数名3，......)

 

 

def MySecondFunction(number1,number2):                下面函数的number1/2是形参

    print(number1,'+',number2,'=',number1+number2)下面函数的a/b是实参

a=1

b=2

MySecondFunction(a,b)

 

#这里要注意Python的自定义函数是自带指针的

#比方说

a=1

def fun(b):

    b=b+1

fun(a)

print(a)==2

#这里a的值变成了2 说明Python自带的指针功能让a的值即使没有返还值也发生了改变

 

 

 

 

13.3有返回值的含参函数：

def 函数名（参数名1，参数名2，参数名3......）

    ......

    return(要返回的值)

 

 

def add(a,b):

    print('a=',a,' b=',b)

    return(a+b)

 

c=add(1,2)

c==3

 

 

 

 

13.4关键字参数：

在使用函数中我们有可能将要使用的函数写反

这时候可以用关键字参数，即给要掉进去的数加名字

def 函数名字(关键字1，关键字2)

    ......

 

函数名字(关键字2=要输入的数2，关键字1=要输入的数1)

 

例：

def shiyan(a,b)

    print(a+'芜湖'+b)

 

shiyan(b='起飞',a='我要')==我要芜湖起飞

 

 

 

 

 

13.5默认参数:

默认参数就是将函数里面的参数给个默认值

def 函数名(关键字1=默认值1，关键字2=默认值2)

    print(关键字1+'->'+关键字2)

例：

def SaySome(name='芜湖',who='大司马')

    print(name+'->'+who)

SaySome()==芜湖->大司马

SaySome('安阳')==安阳->大司马

SaySome('安阳','小司马')==安阳->小司马

 

 

 

 

 

13.6收集参数:

列表可以进入函数里

但如果不在一开始就设置列表

就无法使用函数加上这个列表/元组

这时候可以用收集参数*

def test1(*p):

    print(len(p))

test1(1,2,3,4,5)==5 #这里不加那个星号会报错的

 

当你同时要用收集参数和普通参数时:

需要用关键字参数来指向那个普通参数#否着普通参数会被当做收集参数收集

例

def test2(*p,q):

    print(len(p),q)

test2(1,2,3,4,'wuhu')==报错#'wuhu'被*p收集而消失了q的参数

test2(1,2,3,4,q='wuhu')==4 wuhu

#当然可以用默认参数

def test2(*p,q='dsm'):

    print(p,q)

test2(1,2,3,4,'wuhu')==(1,2,3,4,'wuhu') 'dsm'

 

 

 

 

13.7形参 实参

进去的是形参 在外面的是实参

在了解形参实参后可以用函数调出def后的语句

下面一律用这个例子：

def lizhi(name):

    '在这里写的话可以调出来,这些话可以用来解释这个函数的意思'

    '这里写掉不出来'

    print(name)

 

下面调用解释方法：

（1）

def函数名.__doc__(出现调用的话)

 

lizhi.__doc__==    在这里写的话可以调出来,这些话可以用来解释这个函数的意思

 

（2）

help(def函数名)  《-----（更好用）

 

help(lizhi)==def lizhi(name):

                        在这里写的话可以调出来,这些话可以用来解释这个函数的意思

 

 

 

 

 

13.8全局变量与局部变量

这里可以理解全局变量是def函数外面的变量

局部变量是def函数里面的全局变量

def fun(number):

number = 3

num = 6

这里number 是函数fun里的一个局部变量

num是main里面的全局变量

 

当全局变量是列表的时候 这个全局列表直接引入局部变量后可以在函数内直接进行修改

修改后main中的这个列表也会发生改变

def fun1(a):

a.append('wuhu')

list1=[1,2,3,4]

fun1(list1)      #这里全局变量列表list1进入了fun1（）里面 但它完成了修改

print(list1)==[1,2,3,4，‘wuhu’]

 

当全局变量不是序列的时候 引入函数中是不可以修改的(只能访问)

非要修改可以用global语句

def fun3():

global number                         <-通过引入了引入了number

number =number+1

number =3

fun3()

print(number)==4

 

 

 

13.9内嵌函数：

Python是支持函数的内嵌的 也就是说可以在函数里面套函数(包括函数的使用)

def fun1():

ptint('first')

def fun2():

print('second')

fun2():

fun1()       <-first

                <-second

 

其中内部函数的作用域都在外部函数之内

在main()内无法对fun2()进行调用

 

想在内嵌函数中引用函数的变量时 需要用nonlocal

def fun1():

num=1

def fun2():

nonlocal num   <-用nonlocal在fun2()中引用了fun1()的num变量

num=100

print(num)

fun2()

print(num)

fun1()

---------------------------------------------打印结果将会是：1

--------------------------------------------------------------  100

--------------------------------------------------------------  100

 

一个有趣的例子

def fun1():

global number

print('改变前的number:',number)

num=number

number=233

print('在fun()1中改变后的number:',number)

def fun2():

nonlocal num

num = 666

print('在fun()2中改变后的num:',num)

fun2()

number=520

fun1()

 

#这里注意：在fun1中引用的number 无法在fun2中直接用nonlocal使用

 

运行结果--------------改变前的number:520

-----------------------在fun()1中改变后的number:233

-----------------------在fun()2中改变后的num:666

 

13.10lambda函数

lambda 变量名 : 表达式

 

在平时创建函数时

def fun1(x):

return(2*x+1)

当函数比较简单时可以用lambda等效创建

fun1 = lambda x : 2*x+1

fun2= lambda x,y:x*y

 

使用也很简单

fun1(5)--------------<=2*5+1=11

fun2(1,2)-----------<=1*2=5

 

 

 

 

 

13.11 过滤器函数filter()

filter()

列表名= filter(函数/none,要塞选的列表名)

当为none时 后面的列表名为True时被选中 为False时被淘汰

当为函数时 函数返还True/1时被选中 为False/0时被淘汰

例：判断是否为2的倍数

def fun(x):

if x%2==0:

return True

else:

return False

number = [1,2,3,4,5,6]#-----------------------< 要测试的列表

num =list( filter(fun,number))

print(num)#---------------------------------------<=[2,4,6]

 

将lambda与filter结合

num=list(filter(lambda x : x%2==0,[1,2,3,4,5,6]))

print(num)-----------------------------------------<=[2,4,6]

 

13.12 执行器函数map()

map()

map()与filter()相反

map是将可迭代对象一一进入函数进行赋值 然后留下赋值后的数并组成数列

列表名 = map(函数,要改变的可迭代对象)

 

number = [1,2,3,4,5]

num = list(map(lambda x : x*x,number))

print(num)-----------------------------------------<=[1,4,9,16,25]

 

 

 

13.13 递归函数：

在Python的使用中 我们可以在一个函数中再次调用这个函数

使用递归时一定要有出来的办法，否则会死循环

简单的 错误的例子:
def error():

error()

error()

在使用error()时 error函数在无限的被调用 因此会出现错误

 

但是使用好会成为Python很强大的工具

def fun1(x):

if x==1:

return 1

else:

return x*fun1(x-1)

fun1(5)

这个就是n的递归

 

 

 

 

 

 

 

 

 

 

 

 

 

 

14.类对象：

个人感觉 类对象是用起来更舒服的def

类的两个个关键部件：

类（class）属性   方法

创建类对象：

class 类名称():

    <statement-1>

    ...

    <statement-n>

 

属性与方法的分离

这里我创建一个简单的类:

class fun:

    i=123456789          <-----属性

   def fun233():            <-----方法

        return 'wuhu'

下面调用i和fun233()的方法也很简单：

j=class()

print(j.i)==123456789

print(j.fun233())=='wuhu'

 

 

 

 

 

 

 

 

 

 

 

15.错误解决函数:

15.1 try/except

try:

    尝试运行的函数

except Exception [as reason]:

    运行失败运行的函数（没有失败则忽视这条语句）

 

可以配合while语句:

while True:

    try:

        a=int(input('输入一个整数'))

        break

    except ValueError:

        print('请输入整数')

 

15.2 finally:

try:

检测范围

except Exception [as reason]:

出现异常(exception)后执行的代码

finally:

无论如何都会执行的代码

 

15.3 else:

try:

检测范围

except Exception[as reason]：
出现异常

else:

只有try执行才会执行的代码

try:

int('123')

except ValueError as reason:

print('Error')

else:

print('No Error')---------------------------------------------------------No Error

try中语句顺利执行 else中语句也执行

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

15.3 raise

raise 可以指定一个异常

raise [Exception]

raise[FileNotDoundErro]

会直接出现FileNotDoundError错误

 

 

15.4 with as

with as 可以被看作简化版本的try except

try:=================================with open('text.txt','w') as f:

f=open('text.txt','w')                   f.write('1')

f.write('1')

finally:

f.close()

 

16. 文件

文件的各个函数会允许你创建文件 编辑文件 访问文件

16.1 文件的格式

.txt -----------文本文件

.py ------------Python专用文件

.ppt -----------ppt文件

.jpg ------------图片文件

.mp4 ----------音乐文件

.avi ------------视频文件

.exe------------可打开应用程序

 

16.2 打开文件

open(file,mode)-------------(mode默认为'r')

file:

路径

一般文件的路径为例

C:\windows\system32\cmd.exe

由于Python中\不能直接打出来 所以为

F:\\windows\system32\\cmd.exe

open('F:\\windows\system32\\cmd.exe',mode)

 

mode:

打开模式:

对文件不同的打开模式会让你对文件的修改权限有所不同

t---文本模式（默认）

x---写模式，新建一个文件，如果改文件存在会报错

b---二进制模式

+---打开一个文件进行更新（可读可写）

r---以只读的方式打开文件。文件的指针会放在开头。这是默认模式

rb--以二进制格式打开一个文件用于只读。一般用于图片等非文本文件

r+---打开一个文件用于读写。文件指针将会放在文件的开头

rb+-以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。一般用于图片

w---打开一个文件用于写入。如果文件已存在则会打开文件，原内容消失，没有则创建文件

wb--以二进制打开文件只用于写入，类似w 一般用于非文本文件如图片

w+--打开一个文件用于读写

wb+-用二进制打开一个文件用于读写 一般用于图片

a---打开一个文件用于追加。如果文件存在，指针会再最后，也就是说新内容会放在后面

ab--用二进制打开一个文件用于追加 指针在末尾

a+--打开一个文件用于读写。指针在最后

ab+以二进制格式打开一个文件用于追加，指针在最后

 

个人觉得比较重要的是(r    w+     a)

 

16.3关闭文件

file.close()

a=open('F:\\try2\\try2.txt','a')

a.close()----------------------------------之后a会被关闭

 

16.4 缓存文件

file.flush()

在写入文件时 写的内容不会立即写到文件里 而是等待缓存

用这个函数会让你不用等待主动缓存

a=open('F:\\try2','r')

a.flush()

 

16.5 访问/读取文件

file.read([size])

F:\whytry中文件内容为：wuhu

                      dashima

 

a=open('F:\\whytry','r')

a.read()----------------------------------------<=wuhu\ndashima

a.read(3)--------------------------------------<=wuh

 

 

file.readline([size])

读取文档最多一行

file.readline(3)就是访问当前行的前3个字符（不会超过这一行）

 

file.readlines([sizeint])

读取行并返回列表

sizeint是行数

file.readlines(3)就是访问当前往后的3行 (0就是访问所有)

下与.readline一起的例子

a=open('F:\\try.txt','a')

a.write('我\n爱\n小\n甲\n鱼')

a.seek(0)

a.readline(4)---------------------'我\n'

for i in a.readlines():

line = line.strip()#去除左边的空格 不让打印出来会多出一行

print(line)-------------------------------------------------------------------- 爱

     小

   甲

   鱼

 

for i in file:

print(i)

可以打印出原文件文本

 

 

16.6 写文档

file.write(str)

a=open('F:\\whytry.txt','a')

a.write('\nLLY芜湖')

这样在F盘中的whytry文本会被添加了一行LLY芜湖

 

file.writeline(list)

这个可以把一个字符串的列表输入文件里 但换行需要自己加\n

 

16.7 文件指针

在访问或写文件时 都会有指针的存在

'r'会让指针从头开始 'a'会让指针从末尾开始

要偏移当前指针的位置则需要用到

file.seek(offset[,whence])                offset 偏移量  whence 开始偏移位置

offset没什么好说的 就是要偏移的字符量 -的则为反向

whence:可选 默认为1  0:从头开始 1:从当前指针位置开始 2:从末尾开始

例：

a=open('F:\\try1','w')

a.write('abcde')

a=open('F:\\try1','r')

a.read(1)-------------------'a'

a.seek(0) a.read(2) ------'ab'

a.seek(1) a.read(1) ------'d'

a.seek(4,0) a.read(1) ---'e'

 

file.tell()

会告诉你当前指针的位置

用file.seek()也会返还当前指针的位置

 

 

 

 

 

 

 

17 os模块

os系统操作模块

使用前要先import os

 

17.1 os.getcwd()                                       dir 目录  path 小道

返还当前工作目录

import os

os.getcwd()-----------'F:\\学习\\python38'

会返还当前文件的目录

 

17.2 os.chdir(path)

改变工作目录

import os

os.chdir('E:\\')

os.getcwd()-----------'E:\\'

 

17.3 os.listdir(path)

列举path中的所有文件名(包括隐藏名)

os.listdir('E:\\')---------['$RECYCLE.BIN', '6C0D3FE78100', 'BaiduNetdiskDownload', ......]

列举除了E盘中的所有文件名称

 

17.4 os.mkdir(path)        ----<= 这个只能创建文件夹 makedirs也是(make)

创建单层目录 不能一次创建多个文件 文件已存在则会报错

os.mkdir('E:\\A')

会再E盘创建一个名为A的文件夹

os.mkdir('E:\\B\\C')--------------------报错(因为E盘中没有B文件夹)

 

17.5 os.makedirs(path)

创建多层目录 可以创建多个文件 文件已存在则会报错

os.makedirs('D:\\file1\\file2')

会在D盘中创建file1文件夹和file1内的file2文件夹

 

17.6 os.rmdir(path)         （remove）

删除文件里面的内容

假设E:\\A\\B\\text.txt中有一行为 i love lly的内容

os.remove('E:\\A\\B\\text.txt')

会将里面的内容全部删除

这时候可以用os.rmdir(E:\\A\\B)把B文件夹删除掉

 

17.7 os.removedirs(path)

删除多层文件目录

非空则报错

os.removedirs('E:\\A\\B\\c\\')

 

17.8 os.remove(path)

这个可以删除非空的文件

假设E:\\A\\B\\text.txt中有一行为 i love lly的内容

os.remove('E:\\A\\B\\text.txt')

会将里面的内容全部删除

 

17.9 os.system(command)

打开系统文件

例如cmd calc(计算机)

可以用这个

os.system('cmd')

so.system('calc')

 

17.10 os.curdir

指代当前目录('.')

 

17.11 os.pardir

指代上一级目录('..')

 

 

 

 

 

18. os.path 模块

使用前加上import os

 

18.1 os.path.basename(path)

去掉目录名 返还文件名

os.path.basename('E:\\CloudMusic\\MV')

会返还'MV'

 

18.2 os.path.dirname(path)

去掉文件名 返还目录名

os.path.basename('E:\\CloudMusic\\MV')

会返还'E:\\CloudMusic'

 

18.3 getatime(path)

返回文件最近访问时间

getctime(path)

返还回文件创建时间

getmtime

返回文件最新修改的时间

 

19. pickle模块    pickling 存放 unpickling 读取

pickle模块是Python作者为了存放列表 字典 元组等专门设置的一种文件

文件名末尾为.pkl

编辑pkl时一定要用wb+/ab+

使用前要加入import pickle

 

19.1 pickle.dump(line_name,file_name)

写入序列 可以加入非字符串的东西

import pickle

list1=[1,2,3,'a',[7,'lly']]

pickle_1=open('F:\\textpickle.pkl','wb+')

pick.dump(list1,pickle_1)

pickle_1.close()

这样就把list1写入textpickle.pkl中了

 

19.2 pickle.load(file_name)

读取文件（接上一节）

import pickle

pickle_1=open('F:\\textpickle.pkl','rb')

list1=pickle.load(pickle_1)

print(list1)-----------------------------------[1,2,3,'a',[7,'lly']]

这样就可以保存并打开列表了