01pytbon语法

最新推荐文章于 2024-08-27 16:38:10 发布

岁岁平安·年年岁岁·岁岁年年

最新推荐文章于 2024-08-27 16:38:10 发布

阅读量99

点赞数

文章标签： python numpy 开发语言

本文链接：https://blog.csdn.net/qq_45864291/article/details/127314057

版权

变量

形式：变量值 = 值

举例：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)