Python基础知识
用type ( 变量 ) 可以查看变量的数据类型
1、列表
###定义和值相关
#定义及赋初值
name_list = ['Tom' , 'Lily' , 'Rose']
#取值
name_list[0]
#取值所在的下标
name_list.index('Tom')
#判断值在列表中的数量
name_list.count('Tom')
###新增、修改元素
#新增一个元素在列表末端
name_list.append('xiaoming')
#在指定位置插入一个元素
name_list.insert(1, 'xiaoming')
#在列表末端插入一个列表里的所有元素
name_list.extend(['zhangsan', 'lisi', wangwu])
#复制另一个列表里的元素
name_list2 = name_list.copy()
#修改指定下标的数据
name_list[0]='Lily'
###删除元素
#删除整个列表
del name_list
#删除列表中指定下标的元素
del name_list[0]
#删除指定下标的元素，并返回该元素
pop_return = name_list.pop(1) #没有给参数，默认删除列表最末端元素
#删除指定数据
name_list.remove('Tom')
#清空列表
name_list.clear()
###排序
#列表排序
num_list = [3,6,1,7,4,8]
num_list.sort(key = None, reverse = False/True) #True是降序，False是升序
#列表元素反向排序
name_list.reverse()
###计算长度和遍历
#计算列表的长度
len(name_list)
#遍历
for i in range(len(name_list)):
print(name_list[i])
2、字典
#定义
dict1 = {}
dict1 = dict()
#定义及赋值
dict1 = {'name':'tom','age':10,'gender':'男'}
#其中，: 左侧为key，右侧为value，合起来为item
#新建和修改元素
dict1['age'] = 20 #'age'存在则修改元素的value
dict1['school'] = 'BIT'#'school'不存在，则新建item 'school':'BIT'
#查询
dict1.get('name',110) #如果存在则返回对应value值，不存在则返回参数2
###删除
#删除整个字典
del dict1
#删除某个key值对应的item
del dict1['name']
#清空字典里的元素
dict1.clear()
###遍历
#计算字典的长度
len(dict1)
dict1.keys() #返回可用for循环迭代（遍历）的对象，可以理解为列表
#['name', 'age'. 'gender']
dict1.values() #返回可用for循环迭代（遍历）的对象，可以理解为列表
#['tom', '10'. '男']
dict1.items() #返回可用for循环迭代（遍历）的对象，可以理解为列表
#[('name', 'tom'), ('age', 10), ('gender', '男')]
###字典拆包
dict1={'name':'Tom','age':20}
a,b=dict1
print(a) #name
print(b) #age
print(dict1[a]) #Tom
print(dict1[b]) #20
3、集合
#定义及赋值
s1=set() #创建空集合只能用set(),直接{}是用来创建空字典
#相当于s1=set('')
s2={10,20,30} #创建集合及赋值
#set()和{}定义集合及赋初值的区别，和单双引号无关
#使用set()，括号里必须有单引号，效果如下面所示
s3={'abcdefg','a','b',1,2,3} #{'abcdefg'}
s3=set('abcdefg123') #{'b', 'f', 'd', 'a', 'g', 'e', 'c','1','2','3'}
###增加元素
#增加一个元素
s2.add(100)
#增加一个列表
s2.update([10,20,30,40,50])
###判断元素是否在集合中
10 in s2 #10在集合s2中，返回1(True)
10 not in s2 #10不在集合s2中，返回1(True)
###删除
#删除指定数据，没有则报错
s2.remove(10)
#删除指定数据，没有不会报错
s2.discard(10)
#随机删除数据并返回该数据
pop_return = s2.pop()
#计算集合的长度
len(s2)
注意：元组不可修改
###定义
#创建元组
tup1 = () #创建空元组
tup1 = (50,) #元组中只有一个元素时，要在元素后面加逗号
t1 = (10, 20, 30) #创建多元素元组
#修改元组是非法的，例如
tup1[0] = 100
#但是可以对元组进行连接组合
tup1 = (12,34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2 #(12,34.56,'abc','xyz')
#删除元组
del tup1
#计算元组长度
len(tup1)
#访问元组里的元素
tup1[0]
###判断元素是否在元组中
10 in tup1 #10在tup1中，返回1(True)
10 not in tup1 #10不在tup1中，返回1(True)
注意：列表和元组，可以通过访问下标[0]等访问里面的元素
集合，没有顺序，无法通过下标访问
字典通过[key]访问，例如['age’]
5、推导式
列表推导式
#循环
list1=[i for i in range(10)]
#双循环
list2 = [(i,j) for i in range(1,3) for j in range(3)]
#循环+条件
list3=[i for i in range(10) if i%2==0]
字典推导式
#循环及赋值
list1=['name','age','gender']
list2=['Tom',20,'man']
dict1 = {list1[i]:list2[i] for i in range(len(list1))}
#提取字典中的目标数据，循环、条件语句，赋值
age1={key:value for key,value in dict1.items() if key == 'age'}
6、函数
函数基础
a = 100
###定义函数
def 函数名(参数):
'''函数说明文档''' #三个双引号括起来为函数的说明文档
#查看函数说明文档，用help(函数名)来查看
代码1
代码2
#函数体内部使用全局变量要声明
globel a
a = 200
......
#函数调用
函数名(传入的函数参数) #这种用法，是使用位置参数，传入的参数顺序，需与定义的参数顺序完全相同
函数名(gender = '男',age = 20) #这种用法，是使用关键字参数，关键字不需要按定义的顺序排布
两种特殊参数
###不定长参数
def user_info(*args):#输出是一个元组
print(f'您的姓名是{args}')
user_info('Tom') #您的姓名是('Tom',)
user_info('Tom',18) #您的姓名是('Tom', 18)
###关键字
def user_info2(**kwargs): #输入是一个字典
print(kwargs)
user_info2(name='Tom',age=18,id=110) #{'name': 'Tom', 'age': 18, 'id': 110}
函数高级
###把一个函数作为另一个函数的参数传入
#abs(-10) 绝对值函数
#round(1.2) 四舍五入函数
def sum_num(a, b, f):
return f(a) + f(b)
print(sum_num(1.4, 1.5, abs)) #2.9
print(sum_num(1.4, 1.5, round)) #3
**作用：**函数只有一个返回值，并且只有一句代码，可用lambda简化
语法：lambda 参数列表 : 表达式（有返回值）
**注意：**可以接受任意数量的参数，但只有一个返回值
示例：
###基本用法
#原始函数
def fn1():
return 200
#lambda表达式
fn2 = lambda:200
#原始函数
def add(a,b):
return a+b
#lambda表达式
fn1 = lambda a,b: a+b
###默认参数 c = 100
#lambda表达式
fn1 = lambda a, b, c=100: a + b + c
#调用
fn1(10,20) #只需传两个参数即可执行
#但也可以传入第三个参数，那就以传入的参数为准，不使用默认参数
###可变参数
#不定长参数(元组)，lambda表达式
fn2 = lambda *args: args
print(fn2(10,20,30)) #(10, 20, 30)
#关键字参数(字典)，lambda表达式
fn3 = lambda **kwargs: kwargs
print(fn3(name='python', age=20)) #{'name': 'python', 'age': 20}
###带条件语句
#lambda表达式
fn4 = lambda a, b: a if a > b else b
print(fn4(1000,500)) #1000
###列表中数据按照key值排序
students = [
{'name': 'Tom', 'age': 20},
{'name': 'Rose', 'age': 19},
{'name': 'Jack', 'age': 22}
]
#按name值排序
#student是列表类型，使用.sort里面的key=，则传入列表里的元素，即各个字典给x，
#使用lambda表达式提取出各个字典里的name，作为排序的key依据
students.sort(key=lambda x: x['name'],reverse=False)#默认False，降序排序，True升序排序
print(students) #[{'name': 'Jack', 'age': 22}, {'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}]
8 、异常
###定义异常信息描述类
class ShortInputError(Exception):
def __init__(self,length,min_len):
self.length = length
self.min_len = min_len
#定义异常描述信息
def __str__(self):
return f'你输入的长度是{self.length},不能少于{self.min_len}个字符'
###定义使用try，except，else结构的main()函数
def main():
try:
password = input('请输入密码：')
if len(password) < 3: #如果密码长度不足，抛出异常
raise ShortInputError(len(password),3)
except Exception as result: #捕获到异常
print(result) #输出异常描述信息
else:
print('密码输入完成')
###执行
main()
请输入密码：1
你输入的长度是1,不能少于3个字符
9、文件操作
9.1 文件操作
python中文件操作步骤主要是三个
示例：
###打开
#open(name,mode) #name:路径，,mode(访问模式)：只读，写入，追加等
open('test.txt','w')
#主访问模式
#r：文件不存在，报错，不支持写入操作，表示只读
#w：只写，如果文件不存在，新建文件；写入会覆盖原有内容
#a：追加，如果文件不存在，新建文件，写入不覆盖原有内容
#访问模式可以省略，省略表示访问模式为r
#附加模式
#多b，为用二进制打开，多+为可读可写
#rb，r+，rb+，wb，w+，wb+，
###读写操作
文件对象.write('内容')
文件对象.read(num)#num 长度，不写为读取所有 换行\n也是一字节
文件对象.readlines() #返回一个列表，列表中的元素是文件中的行
文件对象.readline() #读取一行，并将指针移至第二行
###关闭文件
文件对象.close()
###移动文件指针的位置
seek() #用来移动文件指针的位置
文件对象.seek(偏移量，起始位置) #起始位置 0：开头； 1：当前位置； 2：文件结尾
文件备份实例：
#1、用户输入目标文件
old_name = input('请输入要备份的文件名：')
print(old_name)
#2、规划备份文件的名字
#提取目标文件的后缀 最右侧的.才是后缀的.
index = old_name.rfind('.') #rfind(从右侧找)
if index > 0:
postfix = old_name[index:]
#old_name[:index] 文件名
#old_name[index:] 后缀
#组织新名字 原名字+【备份】+后缀
new_name = old_name[:index]+'[备份]'+postfix
#3、备份文件写入数据
#打开文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')
#文件读写操作
while True:
con = old_f.read(1024)
if len(con)== 0:
break
new_f.write(con)
#关闭文件
old_f.close()
new_f.close()
9.2 文件夹操作（OS包）
import os #导入os模块
#使用 os.函数名()
重命名 os.rename(目标文件名，新文件名)
删除文件 os.remove(目标文件名)
创建文件夹 os.mkdir(文件夹名字)
删除文件夹 os.rmdir(文件夹名字)
获取当前目录 os.getcwd(目录)
改变默认目录 os.chdir(目录)
获取目录列表 os.listdir(目录)
批量重命名实例
###批量重命名
import os
file_list = os.listdir()
print(file_list)
for i in file_list:
new_name = 'Python'+i
os.rename(i,new_name)
10、公共操作
公共操作主要包括以下三类：
| 运算符 | 描述 | 支持容器类型 |
|---|
| + | 合并 | 字符串、列表、元组 | | * | 赋值 | 字符串、列表、元组 | | in | 元素是否存在 | 字符串、列表、元组、字典、集合 | | not in | 元素是否不存在 | 字符串、列表、元组、字典、集合 |
10.2 公共方法
10.2.1 len
**作用：**求数据对象里的元素个数
**语法：**len(数据对象)
10.2.2 del
**作用：**删除指定数据对象
语法： del 数据对象
del 数据对象[下标或key] 注意元组不可以更改
10.2.3 max和min
**作用：**求一维数据对象中的最小的元素或最大的元素，如果要求二维或更高维的，可以嵌套调用
语法： min/max ( 数据对象 )
10.2.4 range
**作用：**生成一个元素成等差数列的列表
**语法：**range(start,end,step)
10.2.5 enumerater
**作用：**将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
**语法：**enumerate(sequence, [start=0])
示例：
list1=['a','b','c','f','j']
for i in enumerate(list1):
print(i)
'''
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'f')
(4, 'j')
'''
list1=['a','b','c','f','j']
for i in enumerate(list1,start=1):
print(i)
'''
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'f')
(5, 'j')
'''
tuple
作用：将某个序列转换成元组
list
转换列表
set
转换集合
示例：
list1=[10,20,3,30,50,60]
s1={100,200,300,500,600}
t1=('a','b','v','d')
print(tuple(list1))
print(tuple(t1))
print(list(s1))
print(set(s1))
'''
(10, 20, 3, 30, 50, 60)
('a', 'b', 'v', 'd')
[100, 200, 300, 500, 600]
{100, 500, 200, 600, 300}
'''
|
