python

1. python与大多数其他计算机语言的做法稍有不同，其并不是把值存储在变量中，而更像把名字贴在值的上边。 变量在使用前，需要对其先赋值。

变量名可以包括字母，数字，下划线，但是变量名不能以数字开头（因为python是用c语言写的，所以变量名的规范和c语言差不多）。

符号“=”是赋值的意思，左边是名字，右边是值，不可以写反了。

2. 告诉python创建一个字符串，就要在字符串两边加上引号，可以是双引号或者是单引号。（不可以一边用双引号，一边用单引号），如果我们想打印双引号或者单引号的话，用转义字符。

3. 转义字符

比如：

str='Let's go!'#error
print(str)

上面为错误示范，那么如何输出带有像引号这样的字符串呢？ 这里我们就要用到转义字符了。见下面的例子。

print('Let\'s go!') #输出：Let's go!

print('C:\\now')

如果一个字符串有很多反斜杠这样转就很麻烦，解决方法是在字符串前面加r。(在此方法下，自己尝试输出末尾带有反斜杠的字符串，看看会发生什么情况。）

4. 如何得到一个跨越多行的字符串？（我们需要使用三重引号字符串，单双引号都可以。）

str='''

黄桃芒果酸奶
细拌面
锡纸花甲
emmmm

'''
print(str)

结果：

黄桃芒果酸奶
细拌面
锡纸花甲
emmmm

5. 选择

if-else：通过缩进判断条件分支的部分。

temp=input("Input")
guess=int(temp)
if guess==7:
    print("答对了")
else:
    if guess>8:
        print("猜大了")
    else:
        print("猜小了")
print("GameOver")

6. 循环

while：

guess=0
while guess!=80:
    temp=input("Input:")
    guess=int(temp)
    if guess==80 :
        print("猜对了！")
    else:
        if guess>80:
            print("猜大了!")
        else:
            print("猜小了!")
print("游戏结束!")

for：python的for循环显得更为智能和强大。其for循环可以自动调用迭代器的next方法。

          for  目标 in 表达式

          循环体

a='LOVE'

for i in a:
    print(i,end=' ')

for i in a:
    print(i,len(i))

补充一下range（因为range可以和for搭配使用）：

range（start，stop，step）（有的参数是可以舍弃的）

for i in range(2,15,3):
    print(i)
#输出：2 5 8 11 14

要掌握break和continue。

for i in range(10):
    if i%2 !=0:
        print(i)
        continue
    i+=2
    print(i)

7. and

比较运算符大于逻辑运算符

左边和右边全为true，结果才为true

print( 3>2 and 1<3 )

结果为true。

8. random 模块

用的时候导入random模块。random里有一个函数叫randint（），其会返回一个随机的整数。

import  random
guess=0
secret=random.randint(1,10)
while guess!=secret:
    temp=input("Input:")
    guess=int(temp)
    if guess==secret :
        print("猜对了！")
    else:
        if guess>secret:
            print("猜大了!")
        else:
            print("猜小了!")
print("游戏结束!")

9.  数据

①数据类型

布尔型：（True值为1，False值为0）

print(True+True)#输出2
print(True+False)#输出1
print(True*False)#输出0
print(True*True)#输出1

整型，浮点型，字符串。

②数据转换

这几个类型是可以转换的。

int（）转整型：

如果是字符串转整型的话的话，内容要是数字，如果是中文，英文的话，会出错。

a='2020'
b=int(a)
print(b)#输出2020

str1='hello'
str2=int(str)
print(str2)#出错

如果是浮点型转整型的话，不会采用四舍五入机制，这样效率高。

a=5.99
b=int(a)
print(b)#输出5

float（）转浮点型：

a='2020'
b=float(a)
print(b)#输出2020.0

str（）转字符串：补充一下，很多人个字符串起名字喜欢用str，自己动手试试用str当变量名，在用str（）这个内置函数，看看会发生什么。

str='love'
a=5e17
b=str(a)
print(b)

③获取类型信息

使用type（）获取。

a=2020
print(type(a))#输出： <class 'int'>

isinstance（）判断是否为该类型，返回值为布尔类型。

a='hello'
print(isinstance(a,str))#输出：True
print(isinstance('798',bool))#输出：False

10.  条件表达式

语法：x if 条件 else y

x=9
y=80
small=x if x<y else y
print(small)

11. 断言

assert这个关键字称之为断言，当该关键字后面的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。一般用于为程序置 入检查点。

assert 3<4#无异常
assert 3>4#抛出异常

12. 列表

创建一个普通列表，创建一个混合列表，创建一个空列表。

a=['A','B']
print(a)#输出：['A', 'B']

b=['hello',27,39.90,[34,'world']]
print(len(b))#输出： 4

b=[]
print(b)#输出: []

append（）：

a=['烤冷面','酸菜鱼','锡纸花甲']
a.append('黄桃芒果酸奶')
print(a)#输出：['烤冷面', '酸菜鱼', '锡纸花甲', '黄桃芒果酸奶']

extend（）：使用一个列表扩展另一个列表。

a=['烤冷面','酸菜鱼','锡纸花甲']
a.extend(['猪肉脯','细拌面'])
print(a)#输出：['烤冷面', '酸菜鱼', '锡纸花甲', '猪肉脯', '细拌面']

insert（place,elem）：

a=['烤冷面','酸菜鱼','锡纸花甲']
a.insert(2,'清蒸螃蟹')
print(a)#输出：['烤冷面', '酸菜鱼', '清蒸螃蟹', '锡纸花甲']

从列表中获取元素：数组名[角标]。

从列表删除元素：pop（），del，remove（）。

#remove
a=['A','B','C','D','E']
a.remove('C')#元素为参数的名字，不需要根据位置。

#del
del a[2]
del a#删整个列表

#pop（）
c=['A','B','C']
print(c.pop())
c.pop(1)
print(c)

列表分片：一次获取多个元素。

d=['A','B','C','D','E']
print(d[1:3])#输出：['B', 'C']
print(d[:3])#输出：['A', 'B', 'C']
print(d[1:])#输出：['B','C','D','E']
d1=d[:]#获得了一个列表的拷贝 （注意区别d1=d）

列表比较大小：

从列表的第0个元素开始比较，一旦某位的元素分成胜负，后面的元素不在进行比较。

list1=[12,34,5]
list2=[20,1,1]
print(list1>list2)#False

判断元素是否在列表中：

list1=[12,34,5]
print(34 in list1)#True
print(34 not in list1)#False

常用的BIF：

list1=[12,34,12,5,12,[12,'Tom']]
print(list1.count(12))#数某个元素个数

print(list1.index(34))#判断元素的角标
print(list1.index(12,1,5))

list1.reverse()#原地翻转
print(list1)

list3=[12,34,11,34,54,22]
list3.sort()#从小到大排序
print(list3)

list4=[12,34,11,34,54,22]
list4.sort(reverse=True)#从大到小排序
list4.sort(reverse=False)#从小到大排序
print(list4)

13. 元组

对元组不可以使用插入，删除等等这样的操作。

元组的基本操作：

t1=(12,43,21,32,56,32)#创建一个元组

print(t1[2])#获取元素
print(t1[3:])
print(t1[:5])
print(t1[2:4])

t1=t1[:2]+(888,)+t1[2:]#如何对元组插入元素

注意：

t2=(9,)#为元组
print(t2)

t3=(8)#不是元组
print(t3)

14. 字符串

字符串不可以改元素字符串，如果想要改变字符串内容，和元组类似。

字符串的内置方法：

str1="xiaomingABCxiaoming"
str2='ABC'
str3='I\tlove\tyou! '#把字符串里的tab符号转换为空格，如果不指定参数，一般为8格
str4='       hello world!   '

print(str1.capitalize())#首字母改大写

print(str2.casefold())#改小写

print(str2.center(20))#字符串居中，并生成使用空格填充至长度为20的新的字符串

print(str1.count('xi'))#'xi'出现的次数

print(str1.endswith('ing'))#看字符串是否以一某字符串结束的，startwith（）类似。

print(str3.expandtabs())

print(str1.find('mi'))#找第一次出现该字符串的下标，若没有，则返回值为-1，和index（）一样，不同的是，如果index要查找的没有回返回一个异常

print(str2.istitle())#所有单词以大写开始，其余字母小写，返回True，否则返回False

print(str2.lower())#字符串中所有大写字符转为小写

print(str4.lstrip())#去掉字符串左边所有的空格

print(str1.partition('AB'))#将字符串分成一个三元组（pre_sub,sub,fol_sub),如果字符串不包含sub，则返回（“原字符串'',",",",")

print(str1.replace('xiao','A',1))#将字符串’xiao‘用“A"替换，替换的次数不超过1次

print(str1.rindex('n'))#和index（）功能一样，只是从右边开始

print(str1.split('i'))#以“i"分割字符串

print(str4.strip())#删除字符串前后的所有空格

字符串格式化：

#未知参数
print("{0} love {1} {2}".format("I","you","!"))

#关键字参数
print("{one}  two {third}".format(one='1',third='3'))


输出：I love you !
      1  two 3

如果以上两种一起使用，则未知数参数要在关键字参数之前。

字符串格式化符号，自己了解。

总结：

列表，元组和字符串的共同点：

1.都可以通过索引得到元素

2.默认索引值总是从0开始

3. 可以一个分片法得到一个范围内的元素的集合

4. 有很多共同的操作符

#list()可以将迭代对象转换为列表
str1="hello world !"
str5=(1,3,4,2,1)
str6=[1,3,1,3,4,2]
str1=list(str1)
print(str1)

#str()将对象转换为字符串
str2=str(str1)
print(str2)

#tuple（）将一个可迭代对象转换为元组
str3='hello world!'
str3=tuple(str3)
print(str3)

#len(str)返回长度
print(len(str1))
print(len(str5))
print(len(str6))

#max(),类型要相同
print(max(str6))

#mix（）
print(min(str6))

#sum()
print(sum(str6))

#sorted()
print(sorted(str6))

#reversed(),返回一个对象，如果想要看它的元素，用list（）转成列表的形式
print(list(reversed(str6)))

#zip(),返回一个对象，用list（）查看
a1=[1,32,43,23,43,23,76,56]
a2=[23,535,23,546,2]
a=list(zip(a1,a2))
print(a)

15. 函数

def 函数名（）：

         函数体

和c语言一样，python有形参和实参。

def FirstFunction():
    print("hello world!")
FirstFunction()

def SecondFuntion(num1,num2):
    print(num1+num2)
SecondFuntion(2,3)

def add(num1,num2):
    return num1+num2
print(add(2,7))

函数文档：调用函数不会输出文档，用函数名._doc_会看到函数文档的内容。

def add(num1,num2):
    '实现了一个加法'
    return num1+num2
print(add(2,7))
print(add.__doc__)

关键字参数：

#关键字参数
def ThirdFunction(word1,word2):
    print(word1+'你'+word2)
ThirdFunction('小明','好胖')
ThirdFunction('好胖','小明')
ThirdFunction(word2='好胖',word1='小明')

默认参数：

#默认参数
def Function_4(word1,word2='好胖'):
    print(word1+'你'+word2)
Function_4('小明','好瘦')
Function_4('小明')
Function_4(word2='好胖',word1='小明')

收集参数：参数个数可变

#收集参数
def Function_5(*params):
    print('参数的个数为：',len(params))
    print('第2个参数为：',params[1])
Function_5(12,43,545,'小明')

提醒一下，如果参数里即需要收集参数又需要普通参数，调用的时候应该想下面这样：

def Function_5(*params,a):
    print('参数的个数为：',len(params))
    print('第2个参数为：',params[1])
Function_5(12,43,545,a='小明')

局部和全局变量：局部变量是用栈存储的，所以，出了函数便无法访问了。

def Function_1 (num1,num2):
    sum=num1+num2
    return sum
num1=float(input('请出入：'))
num2=float(input('请输入：'))
num=Function_1(num1,num2)
print(num)
#print(sum)无法访问

函数里可以访问全局变量。但是，如果在函数里修改全局变量的值，其实，python会自动创建一个同名的局部变量。

def Function_1 (num1,num2):
    sum=num1+num2
    num=1000
    print(num)#局部变量，栈
    return sum

num1=1
num2=2
Function_1(num1,num2)
num=888
print(num)

global关键字：

#global关键字
def Function():
    global a
    a=666
    print(a)

a=888
Function()
print(a)

内嵌函数：内部函数的作用域在外部函数之内。在外部函数之外无法调用内部的函数。

#内嵌函数
def Function_1():
    print("Function 1 正在被调用！")
    def Function_2():
        print("Function 2 正在被调用")
    Function_2()

Function_1()

闭包：

#闭包
def funX(x):
    def funY(y):
        return x*y
    return funY

##方法一
i=funX(4)
print(i(10))

##方法二
print(funX(4)(10))


#内部函数直接调用外部函数的局部变量是不行的
##方法一
def Fun1():#通过容器存放，因为容器不是通过栈存放，所以便量不会被屏蔽掉
    x=[5]
    def Fun2():
        x[0]*=x[0]
        return  x[0]
    return Fun2()
print(Fun1())

##方法二，nonlocal关键字
def Fun1():
    x=5
    def Fun2():
         nonlocal x
         x*=x
         return x
    return Fun2()
print(Fun1())

lambda：python写一些执行脚本时，使用lambda可以省下定义函数的过程。

#普通函数
def add(x,y):
    return x+y
print(add(2,4))

#lambda函数，更为简洁
f=lambda x,y:x+y
print(f(2,3))

filter和lambda：

#filter过滤任何非true的内容
print(list(filter(None,[1,0,True])))

def Function(x):
    return x%2
t=range(10)
show=filter(Function,t)
print(list(show))

print(list(filter(lambda x:x%2,range(10))))

16. 递归

def F(x):
    if x==1:
        return 1
    else:
        return x*F(x-1)
number=int(input("请输入："))
print("%d的阶乘是%d。"% (number,F(number)))

17.  字典——python唯一的映射类型

字典不是序列类型，字符串，元组，列表都是序列类型，字典是映射类型。

key：value。

花括号

字典由若干个键和值组成。

dic1={'a':'b','c':'d'}
print(dic1['a'])

还可以通过dict（）创建字典，dict(类型)是工厂函数。

dir1=dict((('a','b'),('c','d'),('e','f')))
print(dir1)

dic3=dict(a='b',c='d')#这里的key不可以用引号
print(dic3)

创建空字典

dic2={}
print(dic2)

直接给字典的键赋值，键存在时，边改写了键的值；如果键不存在，python会为其创建一个新的键，并为其赋值。

dic3=dict(a='b',c='d')
dic3['f']='e'
print(dic3['f'])
print(dic3)

接下来说下字典的内建方法。

fromkeys（）：用于创建并返回一个新的字典。两个参数：第一个是字典的键，第二个（可选）是传入键的值，默认为None。

dict1=dict.fromkeys((1,2,3))#{}和[]都可以
print(dict1)

#{1: None, 2: None, 3: None}

dict1=dict.fromkeys([1,2,3],'hello')
print(dict1)
#{1: 'hello', 2: 'hello', 3: 'hello'}


dict1=dict.fromkeys([1,2,3],['a','b','c'])
print(dict1)
#{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}

访问字典的几个方法：

keys（）：返回字典键的引用

values（）：返回字典值的引用

items（）：items()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回。

get（）：当我们获取字典里的值的时候，一个是通过键值对，即dict['key'],另一个就是dict.get()方法。

#keys
dict1=dict.fromkeys(range(7),'hello')
print(dict1.keys())
#dict_keys([0, 1, 2, 3, 4, 5, 6])

#values
dict1=dict.fromkeys(range(7),'hello')
print(dict1.values())
#dict_values(['hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello'])

#items
dict1=dict.fromkeys(range(7),'hello')
print(dict1.items())
#dict_items([(0, 'hello'), (1, 'hello'), (2, 'hello'), (3, 'hello'), (4, 'hello'), (5, 'hello'), (6, 'hello')])

#get
dic1={}
dic1=dict.fromkeys([1,2,3],'a')
print(dic1.get(1))
#a

如果不知道键是否在字典内，我们可以用成员操作符。in   和not  in 。

dic1={}
dic1=dict.fromkeys([1,2,3],'a')
print(1 in dic1)
#True

clear（）：清空字典

dic1={'a':'b','c':'d'}
print(dic1)
dic1.clear()
print(dic1)

为什么不可以直接dic1={}呢

因为如果dic2=dic1,dic1={}，我们还可以通过dic2查看到内容，因此这并不是真正意义上的清除。

dic1={'a':'b','c':'d'}
dic2=dic1
dic1.clear()
print(dic2)#{}


dic1={'a':'b','c':'d'}
dic2=dic1
dic1={}
print(dic2)#{'a': 'b', 'c': 'd'}

【浅拷贝】copy（）

dic1={'a':'b','c':'d'}
dic2=dic1
dic1[3]='e'
print(dic2)#{'a': 'b', 'c': 'd', 3: 'e'}
print(id(dic1))#和下面的id值相同，只是两个不同的标签贴在同一个值上
print(id(dic2))


#浅拷贝
dic1={'a':'b','c':'d'}
dic2=dic1.copy()
dic1[3]='e'
print(dic2)#{'a': 'b', 'c': 'd'},dic1赋值对dic2没有影响
print(id(dic1))#这两个值是不一样的，说明两个地址不同
print(id(dic2))

pop（）：给定键弹出对应的值。

popitem（）：随机返回并删除字典中的一对键和值。如果字典已经为空，却调用了此方法，就报出KeyError异常。

dic1={'a':'b','c':'d'}
print(dic1.pop('a'))#b,其返回值是对应键的值
print(dic1)#{'c': 'd'}


dic1={'a':'b','c':'d'}
print(dic1.popitem())#其返回值是键值对
print(dic1)#剩余的键值对

setdefault （）：第1个参数表示key，第2个参数表示默认值。如果key在字典中不存在，那么setdefault方法会向字典中添加这个key，并用第2个参数作为key的值。该方法会返回这个默认值。如果未指定第2个参数，那么key的默认值是None。如果字典中已经存在这个key，setdefault不会修改key原来的值，而且该方法会返回key原来的值。

dic1={'a':'b','c':'d'}
print(dic1.setdefault("e"))#setdefault会返回键对应的值，如果没有对自动添加
print(dic1)
#None
#{'a': 'b', 'c': 'd', 'e': None}

update() ：此方法用于更新字典中的键/值对，可以修改存在的键对应的值，也可以添加新的键/值对到字典中。如果有相同的键会直接替换成update的值。

dic1={'a':'b','c':'d'}
dic2={'w':'f','s':'t'}
dic1.update(dic2)
print(dic1)
#{'a': 'b', 'c': 'd', 'w': 'f', 's': 't'}

18. 集合

a={}
print(type(a))#<class 'dict'>字典

b={12,323,121,"hello"}
print(type(b))#<class 'set'>集合类型

集合里的元素是唯一的。

b={12,323,121,"hello",12,323}
print(b)#{'hello', 121, 323, 12}

集合是无序的，无法根据角标对该数据做什么。

b={12,323,121,"hello",12,323}
print(b[2])#会报错

【创建集合的两种方式：】

1. 直接将一堆元素用花括号括起来。

2. 使用set（）工厂函数。可以传字符串，列表，元组做元素。

set1=set((1,2,1,6,7,5,7))
print(set1)

set2=set("hello")
print(set2)

set3=set([12,43,54,12])#列表
print(set3)

【访问集合中的值】

1. 可以用for把集合中的数据一个个读取出来。

2. 可以通过in和not in 判断一个元素是否在集合中已经存在。

set1={1,2,1,5,"hello"}
print(1 in set1)#True
print('1' in set1)#False

#for
set1={1,2,1,5,"hello"}
for i in set1:
      print(i)

【集合中一些内建函数】

#remove
set1={1,2,1,5,"hello"}
set1.remove(1)
print(set1)

#add
set2={23,4,1,4,1,'a'}
set2.add(666)
print(set2)

【frozenset不可变集合】

set1=frozenset({1,2,1,5,"hello"})
set1.add(2)#会报错
print(set1)

19. 异常

#抛出AssertionError
list1=[12,32,43,'A']
assert len(list1)<0

#IndexError
list1=[1,2,3,1]
print(list1[4])

#KeyError字典中查找一个不存在的关键字
dic1={1:3,2:5}
print(dic1[6])
print(dic1.get(4))#get就不会报错


#NameError尝试访问一个不存在的变量
print(s)

#TypeError
print(1+'1')

我们可以在try里检测语句，我们将介绍两种try语句：try——except语句和try——finally语句。

try:
    f=open("8.py")
    print(f.read())
    f.close()
except OSError:
    print("文件出错啦！")

还可以加上比较详细的错误信息：

try:
    f=open("81.py")
    print(f.read())
    f.close()
except OSError as reason:
    print("文件出错啦！"+str(reason))#要强制转换为字符串

一个try还可以和多个except使用：

try:
    s = 1 + '1'
    f=open("81.py")
    print(f.read())
    f.close()
except OSError as reason:
    print("文件出错啦！"+str(reason))#要强制转换为字符串
except TypeError as reason:
    print("类型出错啦"+str(reason))

 

我们也可以将两个异常写到一起：

try:
    s = 1 + '1'
    f=open("81.py")
    print(f.read())
    f.close()
except (OSError,TypeError):
    print("出错啦！T_T")

但是我们有时候并不知道异常是什么，我们就可以写成：

try:
    s = 1 + '1'
    f=open("81.py")
    print(f.read())
    f.close()
except :
    print("出错啦！")

try——finally：

try：

     检测范围

except  Exception ：

      出现异常后处理的代码

finally：

      无论如何都会被执行的代码

代码如下：文件被打开，但是出现了TypeError，所以会跳转到except语句块中，我们必须要将文件关闭，将其放入finally语句块即可。

try:
    f=open("8.py")
    print(f.read())
    s = 1 + '1'
except (OSError,TypeError):
    print("出错啦！T_T")
finally:
    f.close()

【raise】

代码自己引出异常。

raise ZeroDivisionError("除零异常")