Python基础文档

基础

设置编码为utf-8

#coding:utf-8

数字类型

基数、浮点数、字符串、逻辑值（True False）

evel()函数可以自动转换数字类型

变量命名标准

英文字母开始
下划线开始
变量命名区分大小写
变量名不宜太长

数字类型转换

int（s） #字符串转整数
float(s) #字符串转浮点型
str(i) #整数转字符串
str(f) #浮点型转字符串

输入变量数字类型

print(type(s))

格式化输入

m = 12
#第一种格式化方式
#w.pf      w表示宽度，p表示小数点后几位，f表示数字类型
print("|%d|" % m)    |12|
print("|%4d|" % m) #输出占4格（左对齐）  |  12|
print("|%-4d|" m=12% m)  #输出占4格（右对齐）  |12  |
print("|%04d|" % m) #输出占4格，空格用0代替 |0012|
print("|%f|" % m)    |12.000000|
print("|%.f|" % m)  #%.f输出小数点后面0位  |12|
print("|%.4f|" % m)） #%.1f输出小数点后面四位  |12.0000|
print("%d的平方根为%d}" % (m, math.sqrt(m))）
#第二种格式化方式
print(f"{m}的平方根为{math.sqrt(m)}")

运算符

数字运算符

取余一般用于校验位

关系运算符

逻辑运算

字典

字典是一种可变容器模型，且可存储任意类型对象

键必须是唯一的，但值则不必

值可以取任何数据类型，如字符串，数字或元组等

d = {}
# 例：
d = {"a": 1, "b": 2, "c": 3}

遍历字典

d = {"a": 1, "b": 2, "c": 3}

# 第一种遍历方法
for k, v in d.items():
    print(f"这是key: {k},这是value: {v}")

# 第二种遍历方法
for k in d:
    print(f"这是key: {k},这是value: {d[k]}")

增删改查

d = {"a": 1, "b": 2, "c": 3}

#--------查----------
#第一种
d.get("a")

#第二种
d["a"]

#--------改----------
d["a"]=4

#--------增----------
d["h"]=2   #h在字典中没有这个键

#--------删----------
d.pop("a")

遍历字典

#第一种方式
for k, v in d.items():
    print(k, "--", v)
#第二种方式
for k in d:
    print(k, "--", d[k])

常用函数

#获取所有值
d.valuses()
#获取所有键
d.keys()
#拷贝，与直接引用的区别，修改靠背后的值，原字典不会改变，而直接引用会一起改变
dd = d.copy()

将两个列表转换成字典

i = ["姓名", "年龄", "性别"]
v = ['张三',56,'男']
d = dict(zip(i, v))

输出:

{'姓名': '张三', '年龄': '56', '性别': '男'}

列表

列表中可以有字符串和数字

l = []
# 例：
l = [1, 2, 5, 6, 1, 3]

增删改查

l = ['a','b','c']
#--------改----------
l[0]='d'  #0为元素索引号

#--------查----------
l[0]  #0为元素索引号

#--------删----------
l.pop(0)   #通过索引删除元素
l.remove("b")  #通过元素删除元素
del l[0]  #通过索引删除元素
#建议使用前两种进行删除元素

#--------增----------
l.append("d")  # 在最后一个元素后添加元素
l.insert(3, "f")  # 在指定索引位置添加元素

遍历列表

l = [1, 2, 5, 6, 1, 3]
# 第一种遍历方法
for i in l:
    print(i)

# 第二种遍历方法
for i in range(len(l)):
    print(l[i])

常用函数

l.count(元素)   #统计此元素在列表中的个数
l.sort()   #降序排列

过滤重复数据

l = [1, 2, 6, 5, 12, 1, 2, 6, 5]
l.sort()  # 排序列表
# 第一种方式
l = list(set(l))

# 第二种方式
# for i in l:
#     if l.count(i) >= 2:
#         l.remove(i)

print(l)

输出：

[1, 2, 5, 6, 12]

元组

此类型和列表基本一样，区别在于元组初始化了就不能修改其元素，而列表可以

y = (1, 2, 3, 4, 5)

切片

s[start.end,step]可选，冒号必须的, 基本含义是从start开始（包括s[start]），以step为步长，获取到end的一段元素

切片可用于字符串，列表

包前不包后

s = "我爱中国"
 
print(s[::])   # 我爱中国  （输出全部）
print(s[2::])  #中国  （从第二个开始输出）
print(s[2:3:])  # 中  （从第二个开始，第三个结束，不包括第三个字符）
print(s[::-1])  # 国中爱我（倒序输出）

Lambda表达式

m = [chr(c) for c in range(ord('a'), ord('z') + 1)]
print(m)

输出

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

字符串常用函数

将字符串首字母变为大写

name='haojue'
print(name.capitalize()）

输出 :

Haojue

统计字符出现的次数

s = 'Python is good!'
print(s.count('o')）

输出 :

让字符串放在中间

name='ace'  
print(name.center(8,'*')）

输出 :

'**ace***'

判断是否以指定的字符串结尾

name='ace'  
print(name.endswith('a'))
print(name.endswith('e')）

输出 :

False
True

查找字符串位置

s = 'i love python'
print(s.find('l'))
print(s.find('o'))
print(s.find('o',4))  #从第4个字符开始找

输出 :

2
3
11

判断字符是否是大小写

s = "Aa"
for ss in s:
    if ss.islower():
        print(f"{ss}这是一个小写字母")
    if ss.isupper():
        print(f"{ss}这是一个大写字母")

输出：

A这是一个大写字母
a这是一个小写字母

字符串编码互相转换

s='a'
print(ord(s))
print(chr(ord(s)))

输出：s

97
a

其他

# center(width，f1llchar)返回一个指定的宽度 width 居中的字符串，f1llchar为填充的字符，默认为空格。
print('我爱祖国'.center(20,'*'))

#  expandtabs(tabsize=8)把字符串 string 中的 tab符号转为空格，tab符号默认的空格数是8。

#  rfind(str, beg=0 , end=len(string))类似于 find()函数，不过是从右边开始查找.

#  index(str,beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。

#  rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始.

# isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回 False

# isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回True，否则返回 False
a='我爱中国'
print(a.isalnum())
print(a.isalpha())

# isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.

# ljust(width , fillchar)返回一个原字符串左对齐,并使用fillchar填充至长度 width的新字符串，fi1llchar默认为空格

# rjust(width,fillchar)返回一个原字符串右对齐，并使用filLchar(默认空格）填充至长度 width 的新字符串

# max(str)返回字符串 str 中最大的字母。

# min(str)返回字符串 str中最小的字母。

# swapcase() 将字符串转为大写a='test'  TEST
a='test'
print(a.swapcase())

# title（） 标题化返回标的字大写，例如：a='test' Test
print(a.title())

# istitle()如果字符串是标题化的，则返回 True，否则返回 False

# 格式化输出
# ****开始****     ^表示左右填充 10个字符 0表示 k ： 后面表示v值
a='{0:*^10}'.format('开始')
print(a)
b='{num:.2f}'.format(num=3.1415926)
print(b)
# f是3.5以上版本

时间函数

获取当前时间

datetime.datetime.now()  #2023-09-07 11:38:18.324003

格式化输出时间

Y表示年,m表示月,d表示日,H表示时,M表示分,S表示秒

datetime.datetime.now().strftime("%Y:%m:%d")  #2023:09:07
datetime.datetime.now().strftime("%H:%M:%S") #11:35:14

获取时间戳

time.time()  #1694057826.7120156
time.time_ns()  #1694057855870460500

简单条件语句

if语句

格式一：

if 条件:
    
	语句1

格式二：

if 条件:
    
	语句1
    
else:
    
	语句2

格式三：

if 条件:
    
	语句1
    
elif 条件:
    
	语句2
       
else:
    
	语句3

while语句

只有当0或者False作条件时，无法循环

while 条件：
	
    语句

案例

n = 10
i = 1
while i < n:
    j = 1
    while j <= i:
        print(f"{j}*{i}={i * j}", end="\t")
        j += 1
    print()
    i += 1

输出:

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

For循环

for循环中range三个参数设置特定：默认情况系下0开始，步长默认为1，包前不包后

for 循环变量 in range(start,stop,step):
    body

跳出循环的两种方式：

continue   #跳出当前本次循环，进入下一次循环
break    #跳出所有循环，循环结束

案例

# coding:utf-8
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}*{i}={i * j}", end="\t")
    print()

输出:

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

异常处理

常用语句

try:
	语句1
except Exception as err:
	语句2

自定义异常 raise

raise Exception("错误异常信息")

使用例子

while True:
    try:
        x = eval(input())
        if 100 > x > 10:
            print(f"{x}大于10")
            break
        if x > 100:
            raise Exception("值过大")
    except Exception as err:
        print(f"异常：{err}")

函数

函数可以有返回值，也可以没有返回值

函数嵌套默认1000次就会报错

无参数格式：

def 函数名():
    语句

有参数格式：

def 函数名(参数1，参数2):
    print(参数1)
    print(参数2)
    语句

参数可以有默认值

当参数有默认值的时候需要将有默认值的参数放在后面

当调用有参数默认值的函数时，可以不传参，当传参的时候按顺序替换

def 函数名(参数1, 参数2=3, 参数3=4):
    print(参数1)
    print(参数2)
    print(参数3)


函数名(1, 2)

输出:

1
2
4

不定参数args

*args 元组 **args 字典

字典args

例：
def defA(a, b, **args):
    print(args)


defA(1, 2, c=3, d=4, e=5, f=6)

输出：

{'c': 3, 'd': 4, 'e': 5, 'f': 6}

元组args

def defA(a, b, *args):
    print(args)


defA(1, 2, 3, 4, 5, 6)

输出：

(3, 4, 5, 6)

模块

导入模块

一共有三种方式

#第一种
import myModule

myModule.A()
myModule.B()

#第二种，别名
import myModule as my

my.A()
my.B()

#第三种
from myModule import A, B

A()
B()

类与对象

格式

class className:
    block

案例

class Person:
    name = "zhangsan"


print("默认".center(40, "*"))
p = Person()
print("p:", p.name, "----Person:", Person.name)
print("修改Person".center(40, "*"))
Person.name = "lisi"
print("p:", p.name, "----Person:", Person.name)
print("修改p".center(40, "*"))
p.name = "wangwu"
print("p:", p.name, "----Person:", Person.name)

输出：
*******************默认*******************
p: zhangsan ----Person: zhangsan
****************修改Person****************
p: lisi ----Person: lisi
******************修改p*******************
p: wangwu ----Person: lisi

访问权限

默认在类中的变量或函数是公有的，在名字前面加2个下划线"__"即可让其变为私有的

class Person:
    name = "zh"
    __age = 21

    def printInfo(self):
        print("name:", self.name, "age:", self.__age)


p = Person()
p.printInfo()
print(p.__age)

输出：
Traceback (most recent call last):
  File "C:\Users\F410\PycharmProjects\pythonProject\class.py", line 13, in <module>
    print(p.__age)
AttributeError: 'Person' object has no attribute '__age'
name: zh age: 21

可以看出上面实例中，__age变量可以在Person类中调用，不能在类之外调用

方法

三类方法

区别：

普通方法，不能通过类直接调用，只能通过实例化对象调用

类方法，既可以通过类直接调用，也能通过实例化对象调用

静态方法，既可以通过类直接调用，也能通过实例化对象调用

普通方法

class Class1:
    name = "zh"
    
    def fun1(self):
        print(self.name)

类方法

class Class2:
    name = "zh"
    
    @classmethod
    def fun2(cls):
        print(cls.name)

静态方法

class Class3:
    name = "zh"
    
    @staticmethod
    def fun3():
        print(Class3.name)

实例：

class ClassTest:
    name = "zh"

    def fun1(self):
        print(self.name)

    @classmethod
    def fun2(cls):
        print(cls.name)

    @staticmethod
    def fun3():
        print(ClassTest.name)


t = ClassTest()
print("普通方法".center(40, "*"))
t.fun1()
try:
    ClassTest.fun1()
except Exception as e:
    print(e)
print("类方法".center(40, "*"))
t.fun2()
ClassTest.fun2()
print("静态方法".center(40, "*"))
t.fun3()
ClassTest.fun3()

输出：
******************普通方法******************
zh
fun1() missing 1 required positional argument: 'self'
******************类方法*******************
zh
zh
******************静态方法******************
zh
zh

构造方法

构造函数也叫初始化函数（__init__），实例化时优先被调用，用于属性和环境初始化

class T2:
    name = "初始化操作"

    def __init__(self):
        self.name = "zh"

    def show(self):
        print(self.name, self)
        
    # 运行结束时，自动调用，用于环境资源释放和运行环境清理
    def __del__(self):
        print("bye bye")
t = T2()
t.show()

输出：
zh <__main__.T2 object at 0x0000020730820FD0>
bye bye

继承

class T1:
    def __init__(self, name, no, age):
        self.no = no
        self.name = name
        self.age = age

    def show(self):
        print(self.name, self.no, self.age)


class T2(T1):
    def __init__(self, name, no, age, demo):
        T1.__init__(self, name, no, age)
        self.demo = demo


t = T2("zh", 1000, 21, "test")
t.show()

输出:
zh 1000 21

文件操作

打开文件

读文件操作，open方法，第一参数文件位置和名称，第二个参数是文件操作限定：

r只读

w写文件

a追加文件

+表示提升操作范围

rt只读打开一个文件（顺序读）

wt只写打开一个文件（文件存在清空内容，不存在创建一个文件）

at追加打开一个文件（文件存在在末尾追加，不存在创建一个文件）

f = open("file1.txt",'r')

关闭文件

f.close()

读文件

f.read()  #读取全部
f.readline() #一行一行读，可以传入一个整数限制读取字符的字数

读文件的实例

方法一:

try:
    f = open("E:\\file1.txt", 'r')
    t = f.read()
    print(t)
    f.close()
except Exception as err:
    print(err)

方法二：

with open("file1.txt",'r') as f1:
    k = f1.read()
    print(k)

写文件

f.writelines()  #一行一行写，参数可以是字符串，也可以是字符串数组

常规操作

json与字典互相转换

with open("c.json", 'w') as f:
    d = {"name": "zh", "age": 18}
    jsons = json.dumps(d)
    f.write(jsons)

with open("c.json", 'r') as f:
    d = json.loads(f.read())
    print(d, type(d))

yaml与字典互相转换

pip install pyyaml

import yaml

with open("c.yaml", 'w') as f:
    d = {"name": "zh", "age": 18}
    yamls = yaml.dump(d)
    f.write(yamls)

with open("c.yaml", 'r') as f:
    print(yaml.load(f.read(), Loader=yaml.BaseLoader))

连接数据库

import pymysql as pymysql

con = pymysql.connect(host="127.0.0.1", port=3306, user="root", password="123456", database="cloud")
cursor = con.cursor()
# 查
# SELECT * FROM `cloud`.`user` LIMIT 0, 1000
cursor.execute("SELECT * FROM `cloud`.`user`")
result = cursor.fetchall()
print(result)

# 增
# INSERT INTO `cloud`.`user`(`name`, `age`) VALUES ('zh', 21)
cursor.execute("INSERT INTO `cloud`.`user`(`name`, `age`) VALUES ('ywj', 20)")
con.commit()

# UPDATE `cloud`.`user` SET `age` = 23 WHERE `name` = 'ywj' AND `age` = 20 LIMIT 1
# 改
cursor.execute("UPDATE `cloud`.`user` SET `age` = 25 WHERE `name` = 'ywj' AND `age` = 23")
con.commit()
# 刪
# DELETE FROM `cloud`.`user` WHERE `name` = 'ywj' AND `age` = 20 LIMIT 1
cursor.execute("DELETE FROM `cloud`.`user` WHERE `name` = 'ywj' AND `age` = 25")
con.commit()

# 1释放连接
con.close()

socket

服务端

# coding:utf-8
'''
1、需要建立套接字
2、进行监听
3、发生信息
4、接收信息
5、关闭套接字
'''
import socket

sl = []
s = socket.socket()
host = "192.168.0.33"
port = 12345
s.bind((host, port))
s.listen()
print(f"服务器{host}开始监听".center(50, "*"))


def recode(sl):
    with open("r.txt", 'w') as f:
        f.writelines(sl)


while True:
    c = s.accept()[0]
    print('客户端已连接')
    data = "欢迎访问服务器".encode()

    n = c.send(data)  # 发给客户端。
    d = c.recv(1024)
    d = d.decode()
    # print(d)
    sl.append(d + "\t")
    print(sl)
    recode(sl)
# 一下是关闭连接和套接字
c.close()
s.close()

客户端

# coding:utf-8
import socket

s = socket.socket()
host = "192.168.0.170"
port = 12345
s.connect((host, port))
print("==============")
d = s.recv(1024)
d = d.decode()
print(d)
s.send("haojue".encode())
s.close()

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可