变量
变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间，变量的值可以被读取和修改，这是所有计算机和控制的基础。
变量命名规则
硬性规则：变量名由字母（广义的Unicode字符，不包含特殊字符）、数字和下划线构成，数字不能开头，大小写敏感（大写的A和小写的a是两个不同的变量），不要和关键字（有特殊含义的单词）和系统保留字（如函数、模块等的名字）冲突。
PEP8要求：用小写字母拼写，多个单词用下划线连接，受保护的实例属性用单个下划线开头，私有的实例属性用两个下划线开头。
数字
int整型
float浮点型
complex复杂型
字符串
\：转义符
r：忽略转义符的作用
+ 以及空格：多个字符串连接
f 搭配{} 或者 {}搭配 format：引用用法
\n：换行
列表
定义：
索引：
切片：
分支结构
关键字：if、else、elif
缩进：如果if条件成立的情况下需要执行多条语句，只需要保持多条语句具有相同的缩进即可
#多重分支
a = 2
if a == 0:
print("a=0")
elif a == 1:
print("a=1")
else:
print("a不等于0,1")
"""
分段函数求值y=3x-5(x>1)，y=x+2(-1<=x<=1)，y=5X+3(x<-1)
可以使用多重分支时就不要使用嵌套
"""
#分支嵌套，分支结构，层次多了会影响代码的可读性
x = 1
if x>1:
y = 3*x-5
else:
if -1<=x<=1:
y = x+2
else:
y = 5*x+3
print(y)
#多重分支，扁平化结构
x = 1
if x>1:
y = 3*x-5
elif -1<=x<=1:
y = x+2
elif x<-1:
y = 5*x+3
print(y)循环结构
循环结构允许执行一个语句或者语句组多次，python提供了for和while循环
for in循环，可搭配range函数
while循环，True循环继续，False循环结束，可使用else语句
break语句可以跳出for和while循环，循环终止
continue语句跳出当前循环，继续下一轮循环
#计算1-100求和
result = 0
for i in range(101):
result = result+i
print(result)
# 加入分支结构计算1-100之间的偶数求和
result = 0
for i in range(101):
if i%2 == 0:
result = result+i
print(result)
#使用python实现1-100的偶数求和
result = 0
for i in range(2,101,2): #第一个2是1-100的第一个偶数为2,101是1-100的循环，最后一个2是步长，2,4,6...
result = result+i
print(result)
#while循环，搭配else
a = 1
while a == 1: a = a+1
else:
print("a != 1")
print(a)
#break语句
for i in range(1,10):
if i == 5:
break
print(i) #打印出的结果为1，2，3，4
#continue语句
for i in range(1,10):
if i == 5:
continue
print(i) #打印出的结果为1，2，3，4，6，7，8，9
#计算机给出1-100随机数由人来猜，直到猜对
import random
computer_number = random.randint(1,100)
while True:
person_number = int(input("请输入一个数字"))
if person_number>computer_number:
print("小一点")
elif person_number<computer_number:
print("大一点")
elif person_number==computer_number:
print("猜对啦")
break
函数
定义函数
函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。
#函数定义
def method(a): #def关键字，定义一个函数起名为method，定义一个参数a
#输入三个"""，再按回车，出现以下说明
"""
:param a:
:return:
"""
print(a) #传参a，打印出1
return a+2 #返回一个值给调用方
print(method(1)) #调用函数，传入参数a为1，打印出3函数的参数
必须参数：如果在函数内有参数，调用时没有给参数传参，就会报错。
默认参数：调用函数时，如果没有传递参数，则会使用默认参数，默认参数在定义函数的时候定义，默认值只会执行一次，这条规则在默认值可变对象时很重要。
关键字参数：kwarg=value形式，在调用函数时添加，在函数调用或定义中，关键字参数必须跟随在位置参数的后面，当存在一个形式为**name的一个形参时，它会接收一个字典，形式为*name时，接收一个包含除了与已有形参列表以外的位置参数的元组的形参
特殊参数：*仅限关键字参数，在【仅限关键字】形参前放置一个*
解包参数列表：*用来解包元组，**用来解包字典。
#必须参数
def method(a): #没有定义一个默认参数
"""
:param a:
:return:
"""
print(a) #报错
method() #不传参
#默认参数
def method(a=0): #定义一个默认参数0
"""
:param a:
:return:
"""
print(a) #打印出0
method() #不传参
#默认值只会执行一次，这条规则在默认值可变对象时很重要
def method(a,b=[]): #定义函数a，函数b为可变值的列表（定义的默认参数为可变值的列表）
"""
:param a:
:param b:
:return:
"""
b.append(a)
return b
print(method(1)) #因为定义函数时，没有给a定义默认参数，所以这个1时传给a的值，默认参数只执行这个，打印出 [1]
print(method(2)) #打印出 [1, 2]，因为b的默认参数[]只会执行一次，所以这里的打印结果不是[1],[2]
#关键字参数必须跟随位置参数后面
def method(a,b):
"""
:param a:
:param b:
:return:
"""
print(a)
print(b)
return b
method(a=1,b=2) #正常传参，打印出1,2
#method(1，b=2) 1是位置参数，b=2是关键字参数，也可打印出1,2
#method(a=1，2) a=1是关键字参数，2是位置参数，报错
#传递字典
def method(**a): #**name的一个形参时，它会接收一个字典
"""
:param a:
:return:
"""
print(a.keys()) #keys为字典里的自带的函数，会把key值都打印出来，打印结果：dict_keys(['a', 'b', 'c'])
method(a=1,b=2,c=3)
#元组传参
def method(*a): #*name时，接收一个包含除了与已有形参列表以外的位置参数的元组的形参
"""
:param a:
:return:
"""
print(a[0]) #a元组的第1个元素（传参的第1个元素），打印出1
print(a[1]) #a元组的第2个元素（传参的第2个元素），打印出2
print(a[2]) #a元组的第3个元素（传参的第3个元素），打印出3
print(a[3]) #a元组的第4个元素（传参的第4个元素），打印出4
method(1,2,3,4) #给a元组传参传4个元素1,2,3,4
#特殊参数：定义函数时，前面加*，那传参时就需要用关键字传参
def method(*,a): #加了*
"""
:param a:
:return:
"""
print(a)
method(a=1) #因为定义时加了*，所以这个调用时传参的时候需要a=1的关键字传参的形式传参，如果是method(1)就会报错
#*用来解包元组
list_a = (1,2) #定义一个元组形式
list(range(*list_a)) #加*解包，不加会报错
print(list(range(0,9))) #打印结果 [0, 1, 2, 3, 4, 5, 6, 7, 8]
#**用来解包字典
def method(a,b,c):
print(a)
print(b)
print(c)
dic1 = {"a":1,"b":2,"c":3} #定义一个字典
method(**dic1) #加了**，就相当于传递的a=1,b=2,c=3，没加就会报错Lambda表达式
可以用lambda关键字来创建一个小的匿名函数。关键字为lambda，lambda的主体是一个表达式，而不是一个代码块，仅能在lambda表达式中封装有限的逻辑进去
#lambda
y = lambda x,y,z:x+y+z
print(y(1,2,3)) #打印结果 6python数据结构
列表：python中可以通过组合一些值得到多种复合数据类型，列表是其中最常见的数据结构，列表通过方括号括起、逗号分隔的一组值得到，一个列表可以包含不同类型的元素，但通常使用时各个元素类型相同。
列表特性（列表内置的方法）：
list.append(x)：在列表的末尾添加一个元素。相当于a[len(a):] = [x]。
list.insert(i,x)：在给定的为位置插入一个元素。第一个参数是要插入的元素的索引，以a.insert(0,x)插入列表头部，a.insert(len(a),x)等同于a.append(x)。
list.remove(x)：移除列表中第一个值为x的元素。如果没有这样的元素，则抛出ValueError异常。
list.pop([i])：删除列表中给定位置的元素并返回它。如果没有给定为宗旨，a.pop()将会删除并返回列表中的最后一个元素。
list.sort(key=None,reverse=False)：对列表中的元素进行排序（参数可用于自定义排序，解释请参见sorted()）。
list.reverse()：反转列表中的元素。
list.clear()：删除列表中所有的元素。相当于del a[:]。
list.extend(iterable)：使用可迭代对象中的 所有元素来扩展列表。相当于a[len(a):] = iterable。
list.index(x[,start[,end]])：返回列表中第一个值为x的元素的从零开始的索引。如果没有这样的元素将会抛出ValueError异常。可选参数start和end的切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个系列的开始计算的，而不是start参数。
list.count(x)：返回元素x在列表中出现的次数。
list.copy()：返回列表的一个浅拷贝。相当于a[:]。
注意：insert，remove或者sort方法，只修改列表，没有打印出返回值——它们返回默认值None。这是python中所有可变数据结构的设计原则。并非所有数据或可以排序或比较（字符串和数字等）。
列表推导式：提供一个更简单的创建列表的方法，常见的用法是把某些操作应用于序列或者可迭代对象的每个元素上，然后用其结果来创建列表，或者通过满足某些特定条件元素来创建子序列。
#生成一个平方列表，比如[1,4,9...]
#使用for循环来写
list_a=[]
for i in range(0,5):
list_a.append(i**2)
print(list_a) #打印结果 [0, 1, 4, 9, 16]
list_a1=[]
for j in range(0,5):
if j != 0:
list_a1.append(j**2)
print(list_a1) #打印结果 [1, 4, 9, 16]
list_a2=[]
for b in range(1,5):
for d in range(1,5):
list_a2.append(b*d)
print(list_a2) #打印结果 [1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
#使用列表生成式来写，列表推导式,可读性比上面更好
list_a=[i**2 for i in range(0,5)]
print("list_a",list_a) #打印结果 list_a [0, 1, 4, 9, 16]
list_a1=[j**2 for j in range(0,5) if j != 0]
print(list_a1) #打印结果 [1, 4, 9, 16]
list_a2=[b*d for b in range(1,5) for d in range(1,5)]
print(list_a2) #打印结果 [1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
元组：元组使用()进行定义，tuple、list、range都是序列数据类型，元组是不可变的，可通过解包、索引来访问
#元组的定义
tuple_a = (1,2,3)
tuple_b = 1,2,3
print("tuple_a",tuple_a) #打印结果 tuple_a (1, 2, 3)
print(type(tuple_a)) #打印结果 <class 'tuple'>
print("tuple_b",tuple_b) #打印结果 tuple_b (1, 2, 3)
print(type(tuple_b)) #打印结果 <class 'tuple'>
#元组的不可变特性
list_a = [1,2,3]
list_a[0] = "abc" #把列表中第一个元素改为abc
print(list_a) #打印结果 ['abc', 2, 3]
tuple_c = (1,2,3)
tuple_c[0] = "abc"
print(tuple_c) #打印结果 报错
h = [1,2,3]
tuple_d = (1,2,h)
tuple_d[2][0] = "a" #把列表h的1改为a，[2]为元组tuple_d的第三个元素，[0]为为元组tuple_d的第三个元素列表中的第一个元素
print(tuple_d) #打印结果 (1, 2, ['a', 2, 3])
g = (1,2,3,"p","p")
print(g.count("p")) #元组中值为p的元素的个数 打印结果 2
print(g.index(2)) #元组中值为2的元素位置，打印结果 1
print(g.index("p")) #元组中值为p的元素位置，以前面的为准，打印结果 3集合：是由不重复元素组成的无序的集，基本用法包括成员检测和消除重复元素，可以使用{}或者set()函数创建集合，如果要创建一个空集合只能用set() 不能用{}。
#集合的定义
a = {1}
b = set()
print(type(a)) #打印结果 <class 'set'>
print(type(b)) #打印结果 <class 'set'>
#空集合定义
c = set()
print(len(c)) #打印长度，打印结果 0，说明b是空集合
#集合内置函数
a = {1,2,3}
b = {1,4,5}
print(a.union(b)) #求ab并集 打印结果 {1, 2, 3, 4, 5}
print(a.intersection(b)) #求ab交集 打印结果 {1}
print(a.difference(b)) #求a中在b中不存在的集合 打印结果 {2, 3}
a.add("a")
print(a) #打印结果 {1, 2, 3, 'a'}
c = "sahhfdfafhd"
print(set(c)) #可打印出去重结果，{'h', 'a', 's', 'd', 'f'}字典：以【关键字】为索引，关键字可以是任意不可变类型，通常是字符串或数字，如果一个元组只包含字符串、数字或元组，那么这个元组也可以作为关键字。
#字典的定义
a_dict = {"b":1,"c":2}
a_dict1 = dict(b=1,c=2)
print("a_dict",a_dict) #打印结果 a_dict {'b': 1, 'c': 2}
print(type(a_dict)) #打印结果 <class 'dict'>
print("a_dict1",a_dict1) #打印结果 a_dict1 {'b': 1, 'c': 2}
print(type(a_dict1)) #打印结果 <class 'dict'>
#字典内置函数
w = {"a":1,"b":2,"c":3,"d":4}
e = dict(a=1,b=2)
print(w.keys()) #打印结果 dict_keys(['a', 'b'])
print(w.values()) #打印结果 dict_values([1, 2])
print(w.pop("a")) #删掉a键值对，并把a值打印出来，打印结果 1
print(w) #打印结果 {'b': 2, 'c': 3, 'd': 4}
print(w.popitem()) #随机删除一个键值对，并把删除的键值对打印出来，打印结果('d', 4)
print(w) #打印结果 {'b': 2, 'c': 3}
f = {}
j = f.fromkeys((1,2,3),"t") #key值1,2,3，t为每一个key值的value
print(j) #打印结果 {1: 't', 2: 't', 3: 't'}
print({i:i*2 for i in range(0,3)}) #用列表推导式定义字典，打印结果 {0: 0, 1: 2, 2: 4}
扫一扫
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
