Python基础知识学习
source link: https://blog.csdn.net/weixin_48179599/article/details/112942692
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Python基础知识
建议有程序语言基础的童鞋阅读,零基础阅读可能会有点费解
点击下载 python最新版本
# 单行注释
''' 多行注释 '''
chr
单个字符'', 'd'
str
字符串(多个chr)'dd', '你好'
int
整数1,2,3,4
float
浮点数3.1415926
bool
布尔Ture, False
list
列表[1,2,3,4]
tuple
元组('name', 'age')
dict
字典{'name':'zzl'}
set
集合{'zzl', 'age', 'gender'}
查看数据类型函数type(变量)
返回该变量的数据类型
数据类型转换函数int(num)
将num转换为整数类型float(num)
将num转换为浮点数类型bool(num)
将num转换为布尔类型str(num)
将num转换为字符串类型
- int bool float 任何两种类型都可相互转换
- 任何类型都可以转换为字符串
- str -> int 要求全部为数字
- str -> float 要求全部为数字,且可存在一个小数点
注:当布尔值False转换为str后, 在转换为bool会变成True
输入和输出
语法 inp = input('提示文本')
注:输入结果为str数据类型,如须做其他操作可进行数据转换
print('hello, world')
- 占位符输出
# %s 的s表示变量的数据类型
print('名字:%s,年龄:%s,性别:%s' % (name, age, sex))
print(f'名字:{name},年龄:{age},性别:{sex}')
算数运算符
+ - * / ** // %
前四个同其他编程语言用法相同
**
表示平方计算 5 ** 2 === 5的2次方
//
表示做除运算后取整%
取余运算
简写形式+= -= *= /= **= //+ %=
注:+
也可用于字符串拼接*
当任意一边为字符串时,则表示重复字符串
常用运算函数
round(num, count)
表示对num四舍五入,并保留小数点后count位
比较运算符
> < >= <= = !=
ord(chr)
返回该chr的ASCII码(只能为单个字符)chr(num)
返回该ASCII对应的字符
逻辑运算符
and
,or
, not
and
真真为真,其他为假(第一项为真则返回第二项的值,如第一项为假则返回第一项的值)or
假假为假,其他为真(第一项为真,则返回第一项的值,如第一项为假,则返回第二项的值)not
取反成员运算符
in
,not in
in
判断某字符是否存在于某字符串'h' in 'hello'
not in
判断某字符是否不存在于某字符串'h' not in 'hello'
# 注意缩进
if bool表达式:
print('执行')
# 注意缩进
if bool表达式:
print('执行语句1')
else:
print('执行语句2')
# 注意缩进
if bool表达式:
if bool表达式2:
print('执行嵌套语句')
else:
print('执行语句1')
else:
print('执行语句2')
# 注意缩进
if bool表达式1:
print('执行语句1')
elif bool表达式2:
print('执行语句2')
elif bool表达式...:
print('执行语句...')
else:
print('如上都不满足,则执行这条语句')
只能在循环语句中使用,只对距离最近的循环起作用
break # 跳出本循环
continue # 结束本次循环,执行下一次循环
while循环
# 注意判断条件
while bool表达式:
print('执行语句')
for循环
# range(start, end, rule) 从start开始,到end-1,间隔为rule,rule的正负表示正序或倒序
# range(1, 11) 输出1~10,不包括最大值11
# range(1, 11, 2) 输出1~10,不包括最大值11, 第三个参数表示为每次间隔2
# range(11, 1, -2) 输出11~2,不包括最小值值1, 第三个参数为负数,则表示为倒序且每次间隔2
# range(5) 简写形式,0~5的范围
for i in range(1,11):
print(i)
循环else结构
只有循环完整执行完毕后,才会执行else语句
当循环过程中执行break语句后,else将不执行
# while
while bool表达式:
print('执行语句')
else:
print('while else语句')
# for
for i in range(10):
print('执行语句')
else:
print('for else语句')
对象是存储单个数据的容器,而列表(数组)就是存储多个数据的容器,任何数据类型都可以存放
# 字面量创建新列表
lst = [1,'2','三']
# 使用list函数创建新列表
lst = list([1,'2','三'])
列表的取值
- 通过索引下标取值
- 使用for循环
获取元素的下标
- list.index(‘元素’) 找不到元素则抛出异常, 可预先使用in方法判断是否存在
获取列表中多个元素(切片)
list[start:end:step]
从start索引位置开始,截取到end-1位置结束,步长为step
其中step可为负值,表示从start位置往左边截取开始
start默认值为0
end默认值为列表长度
step默认值为1
省略参数但 : 必须存在 list[::]
列表的增删改操作
append(item)
在原有的列表末尾添加一个元素
lst = [10, 20, 30]
lst.append(100)
print(lst) # [10, 20, 30, 100]
extend( [] )
在原有的列表末尾至少添加一个元素,添加元素必须是列表(添加多个)
lst = [10, 20, 30]
lst.extend([99, 100])
print(lst) # [10, 20, 30, 99, 100]
insert(index, item)
在原有的列表指定位置添加一个元素
lst = [10, 20, 30]
lst.insert(1, 99)
print(lst) # [10, 99, 20, 30]
- 切片添加多个元素(指定位置添加多个元素)
使用切片把选择到的元素替换掉
lst = [10, 20, 30]
lst[1:] = [99]
print(lst) # [10, 99]
remove(item)
在原有的列表删除一个元素,如果有重复元素只删除一个,如果元素不存在则抛出异常
lst = [10, 20, 30]
lst.remove(20)
print(lst) # [10, 30]
pop(index)
删除指定索引位置的元素,如果指定索引不存在则抛出异常
不传index,则删除末尾元素
lst = [10, 20, 30]
lst.pop(1)
print(lst) # [10, 30]
clear()
清空列表
lst = [10, 20, 30]
lst.clear()
print(lst) # []
- 切片删除元素
使用切片把选择到的元素替换为空
lst = [10, 20, 30]
lst[1:] = []
print(lst) # [10]
- 删除列表,即释放内存(谨慎使用)
lst = [10, 20, 30]
del lst
print(lst) # 会抛出异常, lst is not defined
- 直接重新赋值
lst = [10, 20, 30]
lst[1] = 40
print(lst) # [10, 40, 30]
- 切片修改(批量修改)
lst = [10, 20, 30]
lst[1:3] = [40, 50, 60]
print(lst) # [10, 40, 50, 60]
列表的排序
sort()
在原列表的基础上排序
传入reverse=True降序排序
传入reverse=False升序排序
不传默认升序
# sotr()
lst = [9, 3, 2, 8]
lst.sort()
print(lst) # [2, 3, 8, 9]
# sotr(reverse=True)
lst = [9, 3, 2, 8]
lst.sort(reverse=True)
print(lst) # [9, 8, 3, 2]
# sotr(reverse=False)
lst = [9, 3, 2, 8]
lst.sort(reverse=False)
print(lst) # [2, 3, 8, 9]
sorted(lst[,rule ])
使用内置函数sorted()进行排序,将产生一个新列表对象
传入第二参数reverse=True降序排序
传入第二参数reverse=False升序排序
不传第二参数默认升序
# sorted(lst)
lst = [9, 3, 2, 8]
new_list = sorted(lst)
print(new_list) # [2, 3, 8, 9]
# sorted(lst, reverse=True)
lst = [9, 3, 2, 8]
new_lsit = sorted(lst, reverse=True)
print(new_list) # [9, 8, 3, 2]
# sorted(lst, reverse=False)
lst = [9, 3, 2, 8]
new_lsit = sorted(lst, reverse=False)
print(new_list) # [2, 3, 8, 9]
列表生成式
[i for i in renge(1, 11)]
列表生成的表达式
lst = [i*i for i in renge(1, 6)]
print(lst) # [1, 4, 9, 16, 25]
列表常用函数
- len(list):列表元素个数
- max(list):返回列表元素最大值
- min(list):返回列表元素最小值
字典(对象)
python的内置数据结构之一,以键值对的方式存储数据。在其他语言中也叫对象。
字典的创建方式
info = {'name':'zzl', 'age':18}
info = dict(name='zzl', age=18)
字典的常用操作
- 获取字典中的元素
info = {'name':'zzl', 'age':18}
# []方式
print(info['name']) # zzl
print(info['sex']) # error: keyError
# get()方式
print(info.get('name')) # zzl
print(info.get('sex')) # None
print(info.get('sex', '男')) # 如果sex字段为None的话,则打印 '男' 默认值
- key的判断
in
,not in
info = {'name':'zzl', 'age':18}
# in
print('name' in info) # True
# not in
print('sex' not in info) # True
- key的删除
info = {'name':'zzl', 'age':18}
del info['name'] # 删除name字段
print(info) # {'age':18}
info.clear() # 清空该字典
print(info) # {}
- 新增key
info = {'name':'zzl', 'age':18}
info['sex'] = '男'
print(info) # {'name':'zzl', 'age':18, 'sex':'男'}
- 修改key
info = {'name':'zzl', 'age':18}
info['age'] = 20
print(info) # {'name':'zzl', 'age':20}
获取字典的试图方法
keys()
返回字典的所有key组成的列表
info = {'name':'zzl', 'age':18}
keys = info.keys()
print(keys) # ['age', 'name']
values()
返回字典的所有value组成的列表
info = {'name':'zzl', 'age':18}
values = info.value()
print(values) # [18, 'zzl']
items()
返回字典的所有key:value组成的列表
info = {'name':'zzl', 'age':18}
itmes = info.items()
print(items) # [('age', 18), ('name', 'zzl')]
字典的遍历
info = {'name':'zzl', 'age':18}
for item in info:
print(item,info[item])
# age 'zzl'
# name 18
字典的生成式
items = ['Fruits', 'Books', 'Others']
prices = [98, 97, 95]
d = { item:price for item, price in zip(items, prices) }
print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}
字典的特点
- 字典中的所有元素都是一个key-value对,key不允许重复,value可以重复
- 字典中的元素是无序的
- 字典中的key必须是不可变对象,(即key不能为变量)
- 字典也可以根据需要动态的伸缩
- 字典会浪费较大的内存,是一种使用空间换时间的数据结构
列表的另一种形式,是不可变序列
元组的创建方式
# 直接用小括号书写
t = ('python', 'world', '20')
# 使用内置函数tuple()
t1 = tuple( ('python', 'world', '20') )
t3 = ('python',) # 如果元组只有一个元素,则在元素后面加上 ,
# 获取元组的元素
t[0] # python
元组的遍历
t = ('python', 'world', '20')
for item in t:
print(item)
# python
# world
# 20
- 如果元组中对象本身是不可变对象,则不能再引用其他对象
- 如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
python语言提供的内置数据结构
与列表、字典都属于可变类型的序列
集合是没有value的字典
集合的存储是无序的
集合的创建
# 集合的value不能重复
s = {2, 3, 4, 5, 2, 4}
print(s) # {2,3,4,5}
# set()函数
s1 = set(range(6))
print(s1) # set([0, 1, 2, 3, 4, 5])
s2 = set([1,2,3,5,6,4,3])
print(s2) # set([1, 2, 3, 4, 5, 6])
s3 = set((1,23,5,32,1))
print(s3) # set([32, 1, 5, 23])
s4 = set('python')
print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])
s5 = set({12,4,23,4,12})
print(s5) # set([12, 4, 23])
# 定义集合
s6 = set()
集合的常用操作
s = {10, 20, 30, 40, 50}
# 判断是否存在
print(10 in s) # True
print(70 in s) # False
# 新增
s.add(80)
print(s) # {10, 20, 30, 40, 50, 80}
# 新增多个
s.update({200, 400})
print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}
# 删除
s.remove(10)
print(s) # {20,, 200, 30, 40, 50, 400, 80}
s.remove(900) # error: keyError
s.discard(900) # 如果有则删除900, 没有也不会报错
s.pop() # 随机删除一个, 不能传参
s.clear() # 清空集合
集合间的关系
两个集合是否相等(判断集合中的元素是否完全相等)
s1 = {10, 20, 30, 40}
s2 = {20, 40, 10, 20}
print(s1 == s2) # True
print(s1 != s2) # False
一个集合是否是另一个集合的子集
假如集合s1的元素里包括集合s2的全部元素,则s2是s1的子集
s1 = {10, 20, 30, 40}
s2 = {20, 40}
print(s2.issubset(s1)) # True
一个集合是否是另一个集合的超集
与上相反,假如集合s1的元素里包括集合s2的全部元素,则s1是s2的超集
s1 = {10, 20, 30, 40}
s2 = {20, 40}
print(s1.issuperset(s2)) # True
一个集合和另一个集合是否无交集
如果一个集合里某个元素,在另一个集合里也有存储,则两个集合有交集
s1 = {10, 20, 30, 40}
s2 = {80, 60}
print(s1.isdisjoint(s2)) # False 无交集
字符串的常用操作
字符串的查询操作方法
字符串的大小写转换操作的方法
字符串内容对齐操作的方法
字符串分割操作的方法
判断字符串操作的方法
字符串操作的其他方法
第2个参数指定替换子串的字符串
该方法返回替换后的字符串,替换前的字符串不会发生变化
该方法的第3个参数可以指定最大替换次数cha.join(lst)用
cha
将列表后元组的字符串合并成一个字符串。使用方法为cha.join(lst)
字符串格式化操作
# %s 的s表示数据类型 s:字符串 i:整数
print('我叫%s,我今年%i岁' % ('zzl', 18)) # 我叫zzl,我今年18岁'
# {}里的数字表示后面变量的索引,可重复使用
print('我叫{0},我今年{1}岁,我真的叫{0}'.format('zzl', 18)) # 我叫zzl,我今年18岁,我真的叫zzl'
# 前面加f 可在{}中直接填写变量
print(f'我叫{'zzl'},我今年{18}岁') # 我叫zzl,我今年18岁'
字符串编码和解码操作
# 编码
s = '好好学习,天天向上'
# 使用GBK格式进行编码, 此格式中,一个中文占两个字节
print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'
# 使用UTF-8格式进行编码 此格式中,一个中文占三个字节
print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'
# 解码 (使用什么格式编码,就必须使用什么格式解码,否则会报错)
# 使用GBK格式进行编码
print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好学习,天天向上
# 使用UTF-8格式进行编码
print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好学习,天天向上
函数的定义和使用
# 定义
def 函数名(a, b): # 参数a和b
函数体
return # 返回值
# 使用
函数名()
# 代码演示
def cals(a, b):
c = a + b
return c
res = cals(20, 30) # 50
函数的参数传递
- 位置传参,
cals(20, 30)
,此时a的值是20, b的值是30 - 关键字传参,
cals(b=70, a=30)
此时a的值是30, b的值是70
函数的返回值
- 如果函数没有返回值(函数执行完毕之后,不需要给调用处提供数据),return可以省略不写
- 函数的返回值,如果是1个,直接返回原值
- 函数的返回值,如果是多个,返回的结果为元组
def fun(lst):
odd = [] # 存放奇数
even = [] # 存放偶数
for i in lst:
if (i%2) :
odd.append(i)
else:
even.append(i)
return odd,even
lst = [10, 23, 65, 78, 32, 77]
print(fun(lst)) # ([23, 65, 77], [10, 78, 32])
函数的默认值
在定义函数的时候,可以给形参赋上默认值,当没传参数的时候,函数会取默认值,如果传参和默认值同时存在,传的参数会替换掉默认值
def cals(a, b = 10):
c = a + b
return c
res = cals(20) # 30
res = cals(20, 30) # 50
函数的参数定义
- 个数可变的位置参数
定义函数时,可能无法确定传递的实参个数,这个时候就要使用可变的位置形参。使用*定义,结果为一个元组
def fun(*args);
print(args)
fun(1) # (1,)
fun(1,2,3) # (1, 2, 3)
- 个数可变的关键字参数(指定参数名传递参数)
定义函数时,可能无法确定传递的关键字实参个数,这个时候就要使用可变的关键字形参。使用*定义,结果为一个字典
def fun(**args);
print(args)
fun(a=10) # {'a':10}
fun(a=10, b=20, c=30) # {'a':10, 'b':20, 'c':30}
以上参数在函数定义时,一种方式只能定义一次。
当两种参数定义方式同时存在时,位置形参必须在关键字形参前面
python异常处理机制
try:
可能出现异常的语句放在这里
except 你要捕获的异常类型:
捕获到异常后你想做什么
except 你要捕获的异常类型:
捕获到异常后你想做什么
...
except BaseException as e: # 这种情况是以上异常类型都没捕获到,则执行这块代码
print('出错了', e)
print('程序照常执行')
异常捕获else
try:
可能出现异常的语句放在这里
except 你要捕获的异常类型:
捕获到异常后你想做什么
except 你要捕获的异常类型:
捕获到异常后你想做什么
...
except BaseException as e: # 这种情况是以上异常类型都没捕获到,则执行这块代码
print('出错了', e)
else:
print('如果没有异常则执行else部分')
try…except…else…finally结构
try:
a = int(input('请输入第一个整数'))
b = int(input('请输入另一个整数'))
res = a/b
except BaseException as e:
print('出错了', e)
else:
print('结果为:'res)
finlly:
print('无论是否产生异常,总会被执行的代码')
python常见的异常类型
- 类属性: 类中方法外的变量称为类属性,被该类的所有实例对象共享
- 类方法: 使用
@classmethod
修饰的方法,可使用类名直接访问 - 静态方法: 使用
@staticmethod
修饰的方法,可使用类名直接访问
# Stubent为类的名称,由一个或多个单词组成。(建议类名书写方式为每个单词首字母大写)
class Student:
native_pace = '河南' # 直接写在类里的变量,称为属性
# 初始化函数( 构造函数 )
def __init__(self, name ,age):
# 创建实例的时候 对name和age属性进行赋值
self.name = name
self.age = age
# 定义在类里面的方法为实例方法
def eat(self):
print('吃饭')
# 静态方法 (静态方法里不允许写self)
@staticmethod
def method():
print('使用staticmethod进行修饰,所以我是静态方法')
# 类方法
@classmethod
def cm(cls):
print('使用calssmethod进行修饰,所以我是类方法')
类实例对象
# 类实例创建语法 stu = Student()
# 假设已存在上面的 Student 类
# stu1就是Student类的实例对象,该实例对象中可以访问到类中的属性和方法
stu1 = Student('zzl', 18) # 创建实例
print(stu1.name) # zzl
print(stu1.age) # 18
stu1.eat() # 吃饭
动态绑定属性和方法
# 假设已存在Student类
stu = Student('zzl', 18)
# 绑定 gender 属性
stu.gender = '男'
print(stu.gender) # 男
# 绑定 show 方法
def show():
print('show方法执行')
stu.show = show
stu.show() # show方法执行
面向对象的三大特征
-
封装 (提高程序的安全性)
将数据(属性)和行为(方法)封装到类对象中,在方法内部对属性进行操作,在类对象的外部调用方法。这样无需关心方法内部的具体实现细节,从而隔离了复杂度。在python中没有专门的修饰符用户属性的私有化,如果该属性不想被类对象访问,可以在属性名前面加两个 ‘_’
# 继承
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
class Teacher(Person):
def __init__(self, name, age, teachofyear):
super().__init__(name, age)
self.teachofyear = teachofyear
stu = Student('张三', 20, 10001)
teacher = Teacher('李四', 35, 10)
stu.info() # 张三 20
teacher.info() # 李四 35
# python 支持多继承
class A(class1, class2):
pass
# 方法重写
# 方法重写就是在子类里定义与父类重名的方法,这样就会优先调用子类的定义的方法
定义:每一个.py文件就是一个模块
使用模块化的好处
- 方便其他程序和脚本的导入使用
- 避免函数名和变量名冲突
- 提高代码的可维护性
- 提高代码的可重用性
# 导入模块
import 模块名称 [as 别名]
# 导入模块中的指定函数(or 变量 or 类)
from 模块名称 import 函数/变量/类
包是一个分层次的目录结构,它将一组功能相近的模块组织在一个目录下
- 避免模块名称冲突
包与目录的区别
- 包含__init__.py文件的目录称为包
- 目录里通常不存在__init__.py文件
包的导入import 包名.模块名
文件的读写
内置函数open()创建文件对象
# file = open( filename, [mode, encoding] )
# 假设有一个名为a的文本文件,里面有hello world
file = open('a.txt', 'r')
print(file.readlines()) # ['hello world']
file.close()
常用的文件打开模式
文件对象的常用方法
offset:为正则往结束方向移动,为负则往开始方向移动
whence不同的值代表不同含义:
0:从文件头开始计算(默认值)
1:从当前位置开始计算
2:从文件末尾开始计算tell()返回文件指针的当前位置flush()把缓冲区的内容写入文件,但不关闭文件close()把缓冲区的内容写入文件,同时关闭文件,释放文件对象相关资源
with语句(上下文管理器)
with语句可以自动管理上下文资源,不论什么原因跳出with语句都能确保文件正确的关闭,以此来达到释放资源的目的
# with使用
with open(filename, mode) as file:
pass
目录操作 (os 和 os.path)
- os模块是python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上运行,得到的结果可能不一样
- os模块与os.path模块用于对目录或文件进行操作
import os
# 打开计算器
os.system('calc.exe')
# 打开记事本
os.system('notepad.exe')
# 打开可执行文件
os.startfile('路径')
os模块操作目录相关函数
os.path模块操作目录相关函数
python内置模块
使用import
关键字引入
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK