命名规范
py命名全小写，以下划线 _ 分隔
缩进
py有一套缩进规则，不按规则编写不能通过编译。
1、首行顶格无缩进
2、相同逻辑层保持相同缩进量
3、: 冒号标记一个新的逻辑层
4、PEP8指导使用4个空格作为缩进，规模大的实际开发可能为2个
条件表达式
py使用 y if con else x 表示条件表达式。意思是当con为true时，表达式的值为y，否则为x。相当于c++和java中的三元表达式 con?y:x;
列表推导式
语法格式为：
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
示例
#for循环
old_list = [1,2,3]
new_list = []
for i in old_list:
new_list.append(i*2)
print(new_list)
#列表推导式
new_list = [i*2 for i in old_list]
print(new_list)
#还可以在其中加if判断
new_list = [i*2 for i in old_list if i>1]
#还还可以使用两层for循环
new_list = [(x,y) for x in range(3) for y in range(3)]
print(new_list)
#输出：[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
#可见x为外层循环，y为内层循环
#还还支持嵌套
new_list= [y*2 for y in [x*3 for x in range(3)]]
print(new_list)
#输出：[0, 6, 12]
#字典推导式
my_tuple_list = [('name', '橡皮擦'), ('age', 18),('class', 'no1'), ('like', 'python')]
my_dict = {key: value for key, value in my_tuple_list}
print(my_dict)
#输出：{'name': '橡皮擦', 'age': 18, 'class': 'no1', 'like': 'python'}
注释
#单行注释
#用井号 # 即可
#我被注释了！！！
'''
多行注释
成对的三个单引号 ' 或者双引号 " 即可
我被注释了！！
'''
"""
我也被注释了！
"""元组
1、特点：①列表使用中括号 [] ，元组使用小括号 ()
②元组访问处理速度快
③不能删除或修改元组中某个元素，只能删除整个元组 （del <元组名>）
④特殊情况下元组的括号可以省略
2、创建与访问
#创建元组方法1
tuple1 = tuple((1,2,3))
print(tuple1)
#创建方法2
tuple2 = (4,5,6)
print(tuple2)
#输出：
#(1, 2, 3)
#(4, 5, 6)
'''当要创建的元组中只包含一个元素时，必须带逗号。
如果不带逗号，会将左右括号默认视为运算符'''
tuple3 = (6,)
tuple4 = (6)
print(tuple3[0])
print(tuple4[0])
#输出：
#6
#TypeError: 'int' object is not subscriptable
#访问元组
#与列表一样
tuple5 = (7,8,9)
print(tuple5[1]) #访问tuple5第二个元素
#输出：8输入输出
1、输入可以用input(),input()接受表达式输入，并且把表达式的结果赋值给等号左边的变量
a = input("输入数字：") #输入1212
print(a)
print(type(a))
#输出：
#输入数字：1212
#1212
#<class 'str'>2、输出
name = "张三"
age = 22
print("我叫%s，我今年%d岁了" % (name, age))
#输出：我叫张三，我今年22岁了3、常用格式符号
| 格式符号 | 转换 |
|---|---|
| %c | 字符 |
| %s | 字符串 |
| %d | 有符号十进制整数 |
逻辑运算符
1、and 逻辑与。相当于c++中的&&，是短路与运算。左值false直接作为表达式值，不计算右值；左值true会计算右值并作为表达式的值
2、or 逻辑或 。相当于c++中的 || ，也是短路或运算。左值为true直接作为表达式值，不计算右值；左值为false会计算右值并作为表达式的值
3、not 逻辑非。对于布尔值会进行取反操作，对于非布尔值会先转换为布尔值（对于字符串，非空串为true，空串为false；对于数字，0为false，其他为true），然后再取反
if else
与c不同的是判断条件可以不用加括号，且条件后要加冒号 :
if 判断条件 :
要执行的代码
else if也与c不同，py将 else if 缩减成elif，最后也可以与else连用
if A :
print()
elif B :
print()
else:
while
与c不同的是py没有大括号来限定while要循环的内容，而改用缩进来确定，上面的ifelse也是如此
while 循环条件 :
要执行的代码
for
py中for多了一个句尾的else，可以用来执行不满足条件的代码，for和else行末记得加冒号
for 临时变量 in 列表或字符串等 :
循环满足条件时执行的代码
else:
循环不
满足条件时执行的代码
#示例
name = ''
for var in name:
print(x)
else:
print("no data")
#输出：no data切片
切片时对操作对象截取其中一部分的操作，字符串，列表，元组都支持切片操作。
语法：[起始:结束:步长] //中间时冒号:
值得注意的是，选取的区间为左闭右开型
#示例
name="abcd"
print(name[0:3]) #步长默认为1
#输出：abc字符串常见操作
find
检测字符串A是否存在字符串B中，存在返回索要值，否则返回-1
语法： B.find(A,start,end)
A = "c"
B = "abcdefghijkl"
print(B.find(A,0,len(B))) #0是搜索的起始位置
#输出：2
count
返回字符串A在字符串B中出现的次数，语法格式与find相同，只要将find换为count
replace
将字符串C中的字符串A替换为B,最多换max次
语法：C.replace(A,B,max)
replace函数不会更改原字符串，只会给一个返回值，返回更改后的字符串
C = "abcdef"
print(C.replcae("abc","666"))
print(C)
#输出：
#666def
#abcdefsplit
以str为分隔符切片mystr，max为最大分隔字符数，可以不写
语法：mystr.split(str,max)
mystr = "Here is your new Phone!!"
print(mystr.split(" ",2))
#输出：['Here', 'is', 'your new Phone!!']upper和lower
将字符串全部变为大写，小写
列表常用操作
添加元素（append、extend、insert）
append：向列表添加元素
extend：将一个集合中的元素逐一添加到列表中
insert：在列表指定位置添加元素 ps:insert(index,obj),在index添加obj
#示例
a.append(5)
print(a)
a.extend(b)
print(a)
a.append(b)
print(a)
a.insert(1,0)
print(a)
'''
输出
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 8, 9]
[1, 2, 3, 4, 5, 8, 9, [8, 9]]
[1, 0, 2, 3, 4, 5, 8, 9, [8, 9]]
'''查找元素（in、not in、index、count）
in、not in：存在（不存在）返回true，否则返回false
count：返回元素出现次数
index：返回出现的位置
a = ['a', 'b', 'c', 'a', 'b']
print(a.index('a', 1, 4))
print(a.count('b'))
print(a.count('d'))
print(a.index('a', 1, 3)) #报错，因为'a'不在区间里
Traceback (most recent call last):
ValueError: 'a' is not in list
3
2
0
删除元素（del、pop、remove）
del：根据下标删除
pop：删除最后一个元素
remove：根据元素的值进行删除
mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, ]
print(mylist)
del mylist[1]
print((mylist))
mylist.pop()
print(mylist)
mylist.remove(7)
print(mylist)
mylist.remove(9) #会报错
print(mylist)
'''
输出
Traceback (most recent call last):
mylist.remove(9)
ValueError: list.remove(x): x not in list
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 4, 5, 6, 7, 8]
[1, 3, 4, 5, 6, 8]
'''排序（sort、reverse）
sort：将集合排序为降序，设置reverse=true改为倒序
reverse：将集合逆置
a = [2, 6, 5, 9]
print(a)
a.reverse()
print(a)
a.sort()
print(a)
a.sort(reverse=True)
print(a)
'''
输出
[2, 6, 5, 9]
[9, 5, 6, 2]
[2, 5, 6, 9]
[9, 6, 5, 2]
'''字典
字典是一种可变容器模型，可以储存任意类型对象。键与键值用冒号分隔，每对键与键值用逗号分隔，整个包裹在大括号里面。
语法：dic = { key1 : val1 , key2 : val2 , key3 : val3 }
根据键值访问字典
dic = {'name': 'john', 'id': 666, 'sex': 'm', 'address': 'china'}
print(dic['name'])
print(dic['address'])
print(dic['age']) #不存在会报错
'''
输出
Traceback (most recent call last):
print(dic['age'])
KeyError: 'age'
john
china
'''
#不确定是否存在可以用get()方法，不存在会返回None
print(dic.get('age'))
#输出：None添加元素
使用变量名[‘键名’] = 数据，若'键'不存在字典中，就会新增这个元素
dic = {'name': 'john', 'id': 666, 'sex': 'm', 'address': 'china'}
newAge = input('输入年龄')
dic['age'] = int(newAge)
print(dic['age'])
#输出：
#输入年龄70
#70删除元素（del、clear）
del：删除指定元素
clear()：删除整个字典
dic = {'name': 'john', 'id': 666, 'sex': 'm', 'address': 'china'}
print(dic)
del dic['address']
print(dic)
dic.clear()
print(dic)
#输出
#{'name': 'john', 'id': 666, 'sex': 'm', 'address': 'china'}
#{'name': 'john', 'id': 666, 'sex': 'm'}
#{}
收集字典中所有的key（keys），value（values），（键,键值）（items）
keys() , values() , items() 返回一个包含字典所有key , value , (键，键值)的视图对象。
要注意的是三者返回的并不是list，不能直接用下标访问，但是可以通过list()转成list再用下标访问，三者用法相同。
dic = {'name': 'john', 'id': 666, 'sex': 'm', 'address': 'china'}
print(dic.keys())
print(dic.values())
print(dic.items())
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))
#输出
#dict_keys(['name', 'id', 'sex', 'address'])
#dict_values(['john', 666, 'm', 'china'])
#dict_items([('name', 'john'), ('id', 666), ('sex', 'm'), ('address', 'china')])
#['name', 'id', 'sex', 'address']
#['john', 666, 'm', 'china']
#[('name', 'john'), ('id', 666), ('sex', 'm'), ('address', 'china')]判断key是否存在字典中
语法：键名 in 字典名 //存在返回true，否则返回false
可变类型数据与不可变类型数据
可变类型：在id（内存地址）不变的情况下，value（值）可以改变
不可变类型：value（值）改变，id（内存地址）也会改变（id变了意味着创建了新的内存空间）
可变类型：列表、字典
不可变类型：其他基本都是不可变，如字符串、布尔值、数字、元组、日期
函数
语法： def 函数名 (参数列表) :
函数体
ps：def是define前三个字母
传参
如果传入的参数是可变的对象（如字典、列表等），函数就可以修改原始值，但如果传入的是不可变对象（如数字、字符串、元组），就不会修改原始对象
def expand(a):
for i in range(4):
a[i] *= 10
eg2 = [1, 2, 3, 4] # 列表
eg3 = (1, 2, 3, 4) # 元组
expand(eg2)
expand(eg3) # 会报错，元组不能修改
print(eg2)
print(eg3)
#输出
#Traceback (most recent call last):
# expand(eg3)
# a[i] *= 10
#TypeError: 'tuple' object does not support item assignment
#[10, 20, 30, 40]
#(1, 2, 3, 4)返回值
py的返回值可以有多个
def fun(a,b):
return a*2 , b*3
print(fun(1,1)) //输出：(2,3)
print(type(fun(1,1))) //输出：<class 'tuple'>
局部与全局变量
在函数体内部对不可变类型的数据进行改动，不影响外面的全局变量，因为着相当于新建了一个局部变量，但是使用方法会对外部产生影响。
lambda匿名函数
语法：<函数名> = lambda <参数> : <表达式>
ps：lambda时一个表达式，不是语句；lambda只能包含一个表达式，不能包含复合语句
#例子1
fun = lambda x, y: x + y
print(fun(7, 2))
#输出：9
#例子2
str = lambda a="aaa", b="bbb", c="ccc": a + b + c
print(str())
print(str("zzz"))
print(str("zzz", "ooo"))
'''
输出：
aaabbbccc
zzzbbbccc
zzzoooccc
'''
尾递归
尾递归是指在函数返回的时候，调用自身本身，并且return语句不包含表达式。
尾递归的效果和循环时一样的，普通的递归每加一层递归关系都会增加一层栈帧，每当函数返回会减少一层，所以有时候调用太多会导致栈溢出，而尾递归在执行时始终只会用一个栈帧，不会出现栈溢出的情况
#普通递归
def fun(int n):
if n==1:
return 1
return n * fun(n-1)
#尾递归
def fun(int num , int n):
if num==1:
return 1
return fun(num-1,num * n)文件操作
//新建一个文件
f = open('test.txt','w')
//关闭这个文件
f.close()
6788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
