变量
形式:变量值 = 值
举例:year= 2022
命名规则:
- 变量名可以由字母、下划线和数字组成
- 变量名不能由数字开头
- 变量名区分大小写
- 不能与关键字重名
- 变量名由两个单词组成时候,每个单词都应该用下划线连接
# 变量命名
name="wonglong"
age=22
print("name:",name)
print("age:",age)
显示关键字:
import keyword
print(keyword.kwlist)
[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, 'yield’]
注释
单行注释:
# 单行注释
多行注释:
'''
这是多行注释,用三个单引号
这是多行注释,用三个单引号
这是多行注释,用三个单引号
'''
print("Hello, World!")
"""
这是多行注释
"""
数字类型
数字类型:整型int,布尔bool,浮点float,复数complex(1+2j)
# 整型
num=2
print(type(num))
type(num)
运算符
**:幂返回x的y次幂
//:取整除,返回商的整数部份,向下取整
<>:不等于比较两个对象是否相等
!=:不等于,比较对象是否不相等
# 运算符
a=1
b=2
c=0
print(a+b)
print(b//a)
print(a==b)
字符串
它是python中最常用的数据类型我们常用“ ”或者‘ ’来创建字符串
它不可以在原来的基础上修改
字符串支持很多操作:拼接、分片、索引
字符串中的转义字符序列
字符串中的内置函数(方法)
# 字符串的基本操作
s1="hello"
s2="world"
print(s1+s2)#拼接
print(s1*3)#重复
print(s1[2])#索引
print(s1[2:4])#分片
print(len(s1))#长度
字符串方法:
capitalize():把字符串的第一个字符大写
format():格式化字符串
lower():转化string中所有的大写字符为小写
upper():转化string中所有的小写字符为大写
lstrip():截掉string左边的空格
注意点:
- 字符串转换工具
- 字符串不允许修改
- 字符串格式化表达
# format()
print("{},{}".format("w","L"))
print("{0},{1}".format("w","L"))
print("{1},{0}".format("w","L"))
# 字符串格式化表达
print("Hello %s L"%"W")
print("Hello %d L"%10)
print("Hello %s L %d"%("W",10))
列表(list)
列表就是按照特定的序列的元素的集合,列表的元素可以是数字、字符、字符串,元素之间用逗号分隔。
举例:
example=[1,"wl",2]
# 访问列表元素
print(example[1])
print(example[-1])
# 修改、增加、删除列表元素
example[0]=3
example.append("C")# 末尾添加元素
example.insert(0,"AA")# 指定位置添加元素
del example[0]# 删除元素
example.pop()# 拿出最后一个元素
列表中的方法:
# 列表中的常用的方法
temp=["a","b",5,"c","hello","d","world"]
# remove()删除元素
temp.remove("c")
#sort()排序
temp2=[3,2,34]
temp2.sort()
# sorted()只是输出排序的结果,实际顺序不改变
sorted(temp2)
#reverse()逆序排序
temp2.reverse()# 逆序输出
# len()计算列表中的元素个数
len(temp2)
# 列表中的切片操作
temp3=["a","b",5,"c","hello","d","world"]
print(temp3[1:3])#输出b和5
print(temp3[::2])#输出a、5、hello、world
print(temp3[::-1])# 倒序全部输出
temp3[1:3]=[]# 删除了b和5
元组(tuple)
元组类似于列表,但是在创建的时候元组用圆括号表示(),列表是方括号表示。两者的区别是,元组是不可变的,列表是可变的
元组的特性:
-
任意对象的有序集合
-
通过偏移量存取
-
属于“不可变序列”
-
固定长度,多样性,任意嵌套
# 元组的拼接
T1=("hello",5)
T2=("worle",8)
print(T1+T2)# 元组的拼接
# 元组的重复
print(T1*3)# 将元组重复3遍
# 元组的分片
T3=('a','b','c','d',1,2)
print(T3[1:3])# 输出b和c
# 创建单个元素的元组要加逗号
y=(1,)# 不加逗号y就是一个整型类型
# 元组的转化、方法、不可变性
T = ("d","a","c","b")
temp=list(T)# 转化为列表,就可以使用排序了
# 元组排序还可以用sorted()排序 接受任意序列的对象
sorted(T)
# 元组本身不可变,但是内容可以变
T=(1,[2,3],4)
T[1][0]='hello'# 可以改变列表的元素
字典
字典中的元素是由键key进行索引的,这些键是任意不可变类型,字典是一个无序的、由键-值对构成的元素的集合,且键是唯一的
字典的主要属性:
- 通过键而不是偏移量来读取
- 任意对象的无序集合
- 长度可变,任意嵌套
# 字典
## 字典的常用操作
D={} # 空字典
D={"name":"wl","age":22} # 有两个元素的字典
D={"person":{"name":"wl","age":22}} # 嵌套字典
print(D["person"]["name"]) # 输出wl 获取字典中对应键的值
D =dict(name="wl",age=22) # 通过dict()创建字典
D.keys() # 获取字典中所有的键
D.values() # 获取所有的值
"sex" in D # False 没有sex键
D.copy() # 复制字典
D.clear() # 清除字典
D= {"name":"wl","age":22}
D.get("name")# 获取键对应的值
D.get("sex","没有该元素")# 输出”没有该元素“
D.popitem() # 删除字典末尾的一个键值对
len(D) # 计算长度
D["name"]=["w","l","d"] # 修改name的值
D.pop("age")# 指点删除某一个键值对
集合(set)
集合set是一个无序不可重复元素序列,可以用{}或者set()函数进行创建集合
注意点:创建一个空的集合必须要使用set()
# 创建集合
x={"hello","world"}
x=set(["hello","world"])
z=set()# 这是一个空集合
# 集合运算
x=set("abcde")
y=set("eykosa")
x-y# 在集合x中但是不在集合y中
x|y # 合并两个集合的元素
x&y # 集合x和集合y的交集
x^y # x和y中相同的去掉,其他的合并
# 集合的方法
z={"a","b","c","d"}
z.add("e") # 在末尾添加元素
z.remove("e") # 删除元素
z.update(set["x","y"])# 更新元素进入集合
L=[1,2,3,4]
L_set=set(L)# 将列表转化为集合
小结:
-
一个元素只能在集合中出现一次
-
集合中元素的顺序是任意的
-
add()是插入一个元素,update()是在原来位置上求并集,remove()是直接删除一个元素。
-
集合只能包含不可变的对象类型(不能加入集合,列表等)
if条件语句
x=input("请输入一个数字:")
x=int(x)# 输入的是一个字符串,要进行转化
if x==5:
print("w")
elif x>5:
print("L")
else:
print("wl")
while循环语句
# while循环语句
x=10
while x>0:
print(x,end=" ")# 输出 一个数之后会加上空格
x=x-1
world=["a","b","c"]
while len(world)>0:
temp=world.pop()
print(temp)
x=50
while x:
x=x-1
if x%2!=0:
continue# continue 跳过一次循环,break 跳出循环
print(x,end=" ")
for循环语句
for循环在python中是一个通用的序列迭代器
for可用于字符串、列表、元组和其他内置可迭代对象
# 访问列表的元素
for x in ["a","b","c"]:
print(x)
# 访问字符串
for s in "hello":
print(s,end=" ")
# 访问元组
T=((1,2),(3,4),(5,6))
for (a,b) in T:
print(a,b)
# 访问字典元素
D={"a":1,"b":2,"c":3}
for k in D:
print(k,":",D[k])
for (k,v) in D.items():# 当作整体提取出来
print(k,":",D[k])
# for循环嵌套
x=["a","b","c"]
y=["a","s","c"]
for i in x:
for j in y:
if i == j:
print(i)
迭代器
可迭代对象:常用的可以被for循环迭代的一些数据类型都是可迭代对象如:列表、元组、字典、集合、字符串
迭代器对象:是一个被迭代的对象,可以遍历迭代器中的所有值
迭代协议:所有带有–next–方法的对象会前进到下一个结果,而当到达一系列结果的末尾时,–next–会引发StopIteration异常,这种对象就是迭代器
# 遍历列表,输出
L = [1,2,3,4]
I = iter(L) # 迭代器对象
print(I.__next__()) # 实现了迭代协议
print(I.__next__())
print(I.__next__())
print(I.__next__())
内置函数 range、zip、enumerate
内置函数:range:返回一系列连续增加的整数,可作为for循环的索引
内置函数:zip:返回一系列并行元素的元组,可用于for中内遍历多个序列
内置函数:enumerate:同时生成可迭代对象中元素的值和索引,因而我们不必再手动计数
# range 计数器循环
print(list(range(5)))# 输出0到4
print(list(range(2,5)))# 输出2,3,4 步长为1
print(list(range(0,10,2)))# 输出0 2 4 6 8 步长为2
for i in range(5):
print(i,end=" ")# 输出0到4
# zip 内置函数,并行遍历
L1=[1,2,3,4]
L2=[5,6,7,8]
print(list(zip(L1,L2))) # 输出[(1, 5), (2, 6), (3, 7), (4, 8)]
for (x,y) in zip(L1,L2):
print(x," ",y)
s1="123"
s2="abcds"
print(list(zip(s1,s2))) # 输出[('1', 'a'), ('2', 'b'), ('3', 'c')],其他的没有输出
# 构造字典
keys=["name","age"]
values=["w",22]
D3=dict(zip(keys,values))
# enumerate
s1 ="abcd"
for (index,item) in enumerate(s1):
print(index,item)# 输出 0 a 1 b 2 c 3 d
列表推导
列表推导的优点:
列表推导比手动的for循环运行更加快
只需要更少的代码
列表推导占用内存少,且大部分工作在解释器内部完成
L = [1,2,3,4]
L=[x+1 for x in L]
print(L) # 输出[2, 3, 4, 5]
num=[1,55,44,33,22]
result=[x for x in num if x>10]
print(result) # 输出[55, 44, 33, 22]
x=['a','b']
y=['1','2']
print([i+j for i in x for j in y]) # ['a1', 'a2', 'b1', 'b2']
类和对象
类的设计是为了创建和管理新的对象,同时也支持继承。
什么是对象:对象由类生成,代表程序领域中具体的元素
class Vchicle:
def __init__(self,name,color):
self.name=name
self.color=color
def run(self):
print(self.name+" is running")
class Car(Vchicle):
def race(self):
print(self.name+"can race")
motor = Car("halei","red")
print(motor.name)
print(motor.color)
motor.race()
'''
结果:
halei
red
haleican race
'''
继承、多态
类对象提供默认行为:
class语句创建类对象并将其赋值给一个名称
class语句内的赋值语句会创建类的属性
类属性提供对象的状态和行为
实例对象是具体的元素:
像函数那样调用类对象会创建新的实例对象
每个实例对象继承了类的属性并获得自己的命名空间
在方法内对self属性做赋值运算会产生每个实例自己的属性
class Fruit:
pass
Fruit.name="banana"
Fruit.color="yellow"
# 创建一个对象
apple = Fruit()
apple.name="apple1"
apple.color="gree"
print(apple.name) # 输出 apple1
# 继承
# 定义父类
class Human:
#定义属性
def __init__(self,name,sex):
self.name=name
self.sex=sex
# 定义方法
def speak(self):
print(self.name+" can speak")
# 定义子类
class Man(Human):
def __init__(self,name,sex,height):
Human.__init__(self,name,sex)
self.height=height
# 方法重载
def speak(self):
print(self.name+" can speak,sing")
person =Man("w",23,75)
person.speak() # 输出w can speak,sing
# 多态
# 定义父类
class Car:
def __init__(self,name,color="white",speed=0.0):
self.name=name
self.color=color
self.speed=speed
def run(self,rate):
self.speed=int(self.speed*(1+rate))
# 运算符重载 功能:打印,输出信息
def __repr__(self):
return "[Vehicle: %s ,color : %s, speed: %d]"%(self.name,self.color,self.speed)
motor=Car("helai",speed=60)
motor.run(1)
Electric =Car("T","black",120)
Electric.run(2.0)
for o in (motor,Electric):
print(o)
'''
结果;
[Vehicle: helai ,color : white, speed: 120]
[Vehicle: T ,color : black, speed: 360]
'''
继承的要点:
- 父类列在class语句头部的括号中
- 类从其父类继承属性
- 实例会继承所有可访问类的属性
- 每个object.attribute引用都会启动一个新的独立的搜索
- 逻辑的修改通过创建子类,而不是修改父类
类–运算符重载
定义:在某个类的方法中拦截内置的操作
操作:当类实例出现在内置操作时,python会自动调用你的方法
常用的运算符重载的方法:
- –init–构造函数
- –repr–打印函数
- –getitem–索引、分片、迭代
- –setitem–索引赋值和分片赋值
- –setattr–、–getattr–属性的访问、赋值
- –len–长度
- –iter–,–next–迭代上下文
# __init__ 构造函数
class Car:
def __init__(self,name,color):
self.name=name
self.color=color
def run(self):
print(" %s run"% self.name )
car = Car("T","red")
car.run()
## 结果: T run
#重载 __init__
class Motor(Car):
def __init__(self,name,speed):
Car.__init__(self,name,"black")
self.speed=speed
def run(self):
print(" %s run is cool" % self.name)
helei = Motor("helai",100)
helei.run()
# 字符串显示 __repr__,定义一个在所有情况下都统一显示的模式
class Hello:
def __init__(self,worlds):
self.worlds=worlds
def __repr__(self):
return self.worlds
hello=Hello("hello world")
print(hello) # 输出 hello world
# __getitem__ ,__setitem__
class Num:
def __init__(self,v):
self.v=v
def __getitem__(self, i):
return self.v[i]
def __setitem__(self, key, value):
self.v[key]=value
# __getattr__.__setattr__
class Person:
def __getattr__(self, attr):
if attr=="age":
return 20
else:
raise ArithmeticError(attr)
def __setattr__(self, attr, value):# 属性赋值
if attr=="age":
self.__dict__[attr]=value # 不能写成 self.age=value 这样会陷入死循环 无限递归
else:
raise ArithmeticError(attr+"uselse")
p=Person()
print(p.age)# 20
p2=Person()
p2.age=30
# __len__
class A:
def __init__(self,name):
self.name=name
def __len__(self):
return len(self.name)
a=A("aa")
print(len(a)) # 结果:2
# __iter__ __next__
class I:
def __init__(self,data):
self.data=data
def __iter__(self):
self.index=0
return self
def __next__(self):
if self.index==len(self.data):
raise StopIteration
item=self.data[self.index]
self.index+=1
return item
L=[1,2,3,4]
x=I(L)
for t in x:
print(t)
陷入死循环 无限递归
else:
raise ArithmeticError(attr+“uselse”)
p=Person()
print(p.age)# 20
p2=Person()
p2.age=30
len
class A:
def init(self,name):
self.name=name
def len(self):
return len(self.name)
a=A(“aa”)
print(len(a)) # 结果:2
iter next
class I:
def init(self,data):
self.data=data
def iter(self):
self.index=0
return self
def next(self):
if self.index==len(self.data):
raise StopIteration
item=self.data[self.index]
self.index+=1
return item
L=[1,2,3,4]
x=I(L)
for t in x:
print(t)