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)))
来源：CSDN
作者：panda没有黑眼圈*~*
链接：https://blog.csdn.net/weixin_43677405/article/details/103895249