任何工作,没别的,就是苦练基本功,在篮球场上,我常用非常简单的基本功就可以克敌制胜,工作中也是如此
字符串
- 1:字符串拼接
a="'人民'"
b=123
print("我是"+a+""+str(b))
2:字符串格式化
year=1949
name='人民'
sport='站起来了'
print("%s中国%s从今以后%s "%(year,name,sport))
将数字进行了格式化,同时简单方便。
- 3:字符串的格式化精度控制
!](https://img-blog.csdnimg.cn/45d6102a84504abfb97735abb07c9156.png)
a=12.456
print("%5.1f" %a)
#快速占位符
适合对精度没有要求的可以快速进行格式化
year='新年'
price='123'
print(f"你好{year},挣了{price}钱")
- 对表达式格式化
数据输入
print("告诉我你是谁?")
name=input()
print(f"我知道了,你的名字是{name}")
name1=input("告诉我你的名字是什么?\n")
print(f"我知道了,你的名字是{name1}")
range
continue 和break的使用
break和continue生效范围是一样的,只是continue会继续执行
,详情可见下面两张图
Python函数
通过global关键字来修改
python数据容器
数据容器有以下特点
1:是否支持重复元素
2:是否可以修改
3:是否有序
分为5类,分别是list,元祖tuple,字符串str,集合set ,字典dict
容器的定义,一次性可以存储多个数据
list
1:存储的元素类型是不受限制的
2:列表里面再次嵌入列表叫作嵌套
如何取出数据
1:通过索引
正向下标,和反向下标
注意:不要超出索引范围。
列表的常用操作
name_list=['wang','liu']
print(name_list)
#查询
# 结果为0
print(name_list.index('wang'))
#输出异常,会断掉
#print(name_list.index('wan'))
#修改
name_list[0]='yao'
print(f"修改后的结果{name_list}")
#插入元素
#插入元素后,元素占据指定的位置
#['yao', 'ma', 'liu']
name_list.insert(1,'ma')
print(name_list)
#追加元素,是追加到元素的尾部
#['yao', 'ma', 'liu', 'xiao']
name_list.append('xiao')
print(name_list)
#第二种方法,使用extend将其他的列表追加到尾部
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'sun', 'li']
name_list2=["zhao","qian","sun","li"]
name_list.extend(name_list2)
print(name_list)
#元素的删除
#li 被删除
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'sun']
del name_list[7]
print(name_list)
#del仅仅能够删除元素,没法得到删除的值
name=name_list.pop(6)
#sun被删除
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian']
print(name_list)
#sun 可以得到一个返回值
print(name)
#删除元素的内容
#删除第一个元素
name_list.extend(name_list2)
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
print(name_list)
name_list.remove('zhao')
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
#第一个zhao被删除
#清空整个列表
name_list.clear()
#[] 得到了一个空列表
print(name_list)
#统计元素的数量
name_list=['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
#1 得到了yao的数量
print(name_list.count('yao'))
#统计列表长度
#10
print(len(name_list))
#反转
name_list.reverse()
#['li', 'sun', 'qian', 'zhao', 'qian', 'zhao', 'xiao', 'liu', 'ma', 'yao']
print(name_list)
#列表的遍历
#两种方式可以获取到
def list_while_func():
index=0
while index < len(name_list):
print(f"{name_list[index]}")
index+=1
list_while_func()
def list_for_func():
for i in name_list:
print(i)
list_for_func()
元组,
列表可以被修改,元组不可以被修改,只读的list
t=('zhang','liu','li','zhang','liu','li')
print(len(t)) #6
print(t.count('zhang')) #2
print(t.index('zhang')) #0
#不可以修改,(增加或者删除元素)
#支持for循环
#元组里面如果嵌套了list,那么是可以修改的
字符串
#字符串的操作
#字符串是不可修改的
my_str="happy days everyday"
#如下开始证明
#my_str[2]='H'
"""
Traceback (most recent call last):
File "D:\code\python\venv\Scripts\5.py", line 5, in <module>
my_str[2]='H'
TypeError: 'str' object does not support item assignment
"""
#查找特定的数据
print(my_str.index('days'))
#结果为6
#字符串的替换
#replace方法是得到了一个新的字符串,而不是修改了原来的字符串。
my_replace_str=my_str.replace('h','H')
#结果为happy days everyday
print(my_str)
#结果为Happy days everyday
print(my_replace_str)
#字符串的分割
#按照指定的分割字符串,将字符串划分为多个字符串,并入列表中,
#字符串本身不会变,而是得到了一个列表对象
my_str_list=my_str.split(" ")
#得到了这样的一个list,原来的并没有被改变
#['happy', 'days', 'everyday']
print(my_str_list)
my_str_strip=my_str.strip("h")
#只能对头和尾部进行操作
#appy days everyday
print(my_str_strip)
#统计字符串某个字符出现的次数
print(my_str.count('ay'))
#2
#查看长度
print(len(my_str))
切片操作
其他的如str和列表以及元组都支持切片,在这里不一一练习了
#序列的切片操作
#起始下标,结束下标,步长
#切片后会得到一个新的序列,并不会改变原来的
my_list=[1,2,3,4,5,6,7,8]
my_new_list=my_list[0:8:2]
#输出结果为[1, 3, 5, 7]
print(my_new_list)
my_tuple=(0,1,2,3,4,5,6)
my_new_tuple=my_tuple[-1:-6:-1]
#输出结果为(6, 5, 4, 3, 2)
print(my_new_tuple)
集合
#集合
#集合不支持重复元素
my_set={3,1,2,3,2,3,3}
#{1, 2, 3}
#内容是无序的,不支持下标索引访问,因为一旦发生改变,下标就会全部改变。序列的操作不支持集合,集合是允许修改的。
print(my_set)
#添加新元素
my_set.add(4)
#结果为{1, 2, 3, 4}
print(f"{my_set}")
#移除元素
my_set.remove(1)
{2, 3, 4}
print(my_set)
element=my_set.pop()
#随机取出一个
print(element)
#my_set的值也会发生改变
print(my_set)
#清空方法
my_set.clear()
set()
print(my_set)
my_set={3,1,2,3,2,3,3}
#取出差集
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
#查找到1里面有的,2里面没有的,set2和set1的结果不会发生变化
{2, 3}
print(set3)
#消除差集
#以集合1为标准,删除1和2里面相同的
print(f"取出集合1的值{set1}")
set1.difference_update(set2)
#将两者之间的1给删除掉{2, 3}
print(set1)
#集合2未发生变化{1, 5, 6}
print(set2)
#合并的功能
#{1, 2, 3, 5, 6}
print(set1.union(set2))
字典
#字典
#字典和集合非常像,集合不允许重复的。字典的key也是不允许重复的
my_dict1={"wang":"99","zhang":"66","gong":"77","liu":"44"}
#重复的key值只会存在一个
my_dict2={"wang":"79","wang":"99","zhang":"66","gong":"77","liu":"44"}
print(my_dict2) #新的值会替换掉旧的{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44'}
#获取key后面的值
print(my_dict1['wang']) #99
#新增的key存在,就是新增,如果存在,就是更新
my_dict1['xiao']=78
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44', 'xiao': 78}
#更新
my_dict1['xiao']=90
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44', 'xiao': 90}
#删除
x=my_dict1.pop('xiao')
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44'}
print(x) #90
#清空元素
my_dict1.clear()
print(my_dict1) #{}
#查看所有的key
print(my_dict2.keys()) #dict_keys(['wang', 'zhang', 'gong', 'liu'])
#遍历字典
for key in my_dict2.keys():
print(my_dict2[key]) # 99
#66
#77
#44
#统计字典内的所有信息
print(my_dict2.items()) #dict_items([('wang', '99'), ('zhang', '66'), ('gong', '77'), ('liu', '44')])
print(len(my_dict2)) #4个元素
数据类型分类
数据容器的通用操作
#数据容器的通用操作-遍历
#都支持遍历操作,都支持len,max,min
#支持排序操作
my_list=[9,1,2,3,4,5,6,7]
my_set={9,1,2,3,4,5,6,7}
my_tuple=(3,1,2,5,4)
my_list.sort()
sorted(my_list)
sorted(my_tuple,reverse=True)
sorted(my_set)
print(my_set)
print(sorted(my_tuple))
#sorted是对内容进行排序,返回一个列表
#tuple因为具有不被修改的特性,所以不会被改变
函数的参数传递
#函数
#设置默认值参数得放在最后面
'''
def user_info(name,age,gender="男"):
print(f"姓名是{name},年龄是{age},性别是{gender}")
user_info('wang',14)
#不定长, 位置不定长 *号
#不定长参数也叫可变参数,用于不确定调用的时候会传递多少个参数,
#作用:当调用参数时不确定参数个数时,可以使用不定长参数
'''
#不定长参数的类型
#位置传递,关键字传递
'''
'''
#第一种位置传递
def user_info(*args):
print(args)
return args
#当使用不定长时,args默认会标记为元组,传递参数的时候会传递到元组里面去
a=user_info(18)
b=user_info('wang',18)
print(type(b)) #<class 'tuple'>
#关键字传递的不定长
#数量也是不受限的,但同时也必须满足key=value的形式来让keyargs来接受
def user_info1(**kwargs):
print(kwargs)
return kwargs
a=user_info1(name='wang',id=112,age=18) #{'name': 'wang', 'id': 112, 'age': 18}
print(type(a)) #<class 'dict'>
lambda函数
#关键字传递的不定长
#数量也是不受限的,但同时也必须满足key=value的形式来让keyargs来接受
def user_info1(**kwargs):
print(kwargs)
return kwargs
a=user_info1(name='wang',id=112,age=18) #{'name': 'wang', 'id': 112, 'age': 18}
print(type(a)) #<class 'dict'>
#匿名函数 就是没有名称
#有名称的函数,可以基于名称重复使用。无名称的函数,只能临时使用一次
#使用场景见如下
#lambda 传入参数:函数体
my_list=[1,2,3,4]
def test(x):
result=x(2)
return result
#print(test(my_list[2]))TypeError: 'int' object is not callable
print(test(lambda x:x*2))#test里面的参数必须得是一个函数的地址 #总结lamdba使用的本质为将函数的地址传递给另外一个函数。非常简单好用
#lambad函数提升了一些应用场景,简洁明了
#如果该函数如果需要使用多次,那么就用def,只使用一次就用lambda
异常
#Python异常操作
'''
try :
可能发生错误的代码
except:
如果出现异常执行的代码,如果出现异常,到except里面去执行
else:
如果没有异常,就执行这一步
finally
无论有没有异常,100%都要执行
异常也会进行传递,
'''
try:
f=open("linux.txt","r",encoding="UTF-8")
except: #出现异常了,被except接收
print("出现异常了,文件不存在,改为W模式去打开")
f = open("linux.txt", "w", encoding="UTF-8")
try:
print(name)
except NameError as e:
print(e) #name 'name' is not defined
print("出现了变量未定义")
#捕获多个异常
try:
print(1/0)
except (NameError,ZeroDivisionError): #通过元组将异常捕获
print('错误')
#如果未能设置正确的异常类型,那么会无法捕获
#捕获全部的异常
try:
1/0
except Exception as e: #通过捕获Exception来达到捕获全部的目标,这是通常情况下的写法 Exception是顶级的异常,其他的异常都是
print('异常出现了')
#异常的else:
try:
a=2
print(a)
except:
print('有异常')
else:
print("没有异常")
finally:
print("你好")
模块
#模块的导入
#导入Python内置的模块
#模块就是一个工具包
#中括号表示可选项目[from 模块名]import[模块|类|变量|函数][as 别名]
"""
#import 模块名
import time
time.sleep(5)
print(time.altzone)
#import是直接把所有功能代入,from 是只使用部分功能
from time import sleep
#通过 from这种方式,只能使用sleep
print("你好")
sleep(5)#和import的写法就不一样了,可以只写sleep了,如果只写import,那么必须得加上time
print("你好")
"""
#from time import *
# print("你好")
# sleep(5)#通过这种形式也可以再前面不加time
# print("好")
# import time as t
# #在同一个文件夹下直接引用就行了
# import my_module1
# print("你好")
# t.sleep(5)
# print("hello")
# my_module1.test(1,2)
#
# from time import sleep as sl
#
# print("a")
# sl(5)
# print("b")
#在同一个文件夹下直接引用就行了
# import my_module1
# # my_module1.test(1,2)
# # #第二种引用方式
from my_module1 import *
test_A()
#test_B() #NameError: name 'test_B' is not defined,由于有了__all__变量的产生,导致了
#如果要想单独引用,那么必须得如下操作
from my_module1 import test_B
test_B()
Python 包
在pycharm上直接创建就行了
封装
"""
封装(将现实世界事物在类中描述为属性和方法,即为封装)
私有成员:
定义私有成员变量或者方法,只需要变量名或者方法名以__开头(2个下划线)
类对象无法访问私有成员,类中的其他成员可以访问私有成员
"""
# 演示面向对象封装思想中私有成员的使用
class Phone:
__current_voltage = 0.5 # 当前手机运行电压(对用户隐藏)
def __keep_single_core(self):
print("让CPU以单核模式运行")
def call_by_5g(self): # 手机进入5g模式
if self.__current_voltage >= 1:
print("5g通话已开启")
else:
self.__keep_single_core()
print("电量不足,无法使用5g通话,并已设置为单核运行进行省电。")
phone = Phone()
# print(phone.__current_voltage) # 直接调用私有变量,报错
# phone.__keep_single_core() # 直接调用私有方法,报错
phone.call_by_5g()
继承
"""
继承(从父类哪里继承来成员变量和成员方法,但不含私有)
继承语法如下:
class 类名(父类1,父类2,父类3,...):
类内容体
"""
# 演示继承
class Phone:
IMEI = None # 序列号
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id = "10001" # 面部识别ID
def call_by_5g(self):
print("2022年新功能:5g通话")
phone = Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()
复写
"""
复写(如果要复写父类属性或者方法,只需要在子类中重新定义即可)
如果需要调用被复写的父类的成员:
方法1:
父类名.成员变量
父类名.成员方法(self)
方法2(使用super()):
super().成员变量
super().成员方法()
"""
多态
#多态
"""
多态:多态指的是多种状态,即完成某个行为(函数)时,使用不同的对象会得到不同的状态
在这里有一个和重写的区别,重写是方法,自己的对象调用自己的方法,而多态是对象的使用,
1.主要作用在继承关系上(抽象类,即接口,用于顶层设计作为约束,子类做具体实现):
父类做声明工作
以子类做实际工作
用以获得同一行为,不同状态
"""
"""
演示面向对象的多态特性
"""
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
def make_noise(animal: Animal):
# 制造噪音,需要传入Animal对象
animal.speak()
# 演示多态,使用两个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog) # 汪汪汪 对对象的调用,完成了多态
make_noise(cat) #喵喵喵 同样的行为出现不同的状态,多态都使用在抽象类的场景
"""
演示抽象类(接口)的使用
抽象类用于顶层设计,具体使用
"""
class AC:
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_l_r(self):
"""左右摆风"""
pass
#从下面可以看到,多态长应用于抽象类和抽象方法
class Midea_AC(AC):
def cool_wind(self):
print("美的空调制冷")
def hot_wind(self):
print("美的空调制热")
def swing_l_r(self):
print("美的空调左右摆风")
class GREE_AC(AC):
def cool_wind(self):
print("格力空调制冷")
def hot_wind(self):
print("格力空调制热")
def swing_l_r(self):
print("空调左右摆风")
def make_cool(ac: AC):
ac.cool_wind()
midea_ac = Midea_AC()
gree_ac = GREE_AC()
make_cool(midea_ac)
make_cool(gree_ac)
闭包和装饰器
#闭包的作用
#全局变量有被修改的风险,代码在命名空间上不够干净整洁
#第一种,不使用闭包的场景
account_amount=0
def atm(num,deposit=True):
global account_amount
if deposit:
account_amount+=num
print(f"存款:+{num},账户余额{account_amount}")
else:
account_amount-=num
print(f"存款:-{num},账户余额{account_amount}")
atm(300) #存款:300,账户余额300
atm(300) #存款:300,账户余额600
atm(100,False) #存款:100,账户余额500
#从上面可以看到全局变量在被不断的修改,同时,代码也不够干净
#使用闭包的写法见如下,这种就不会有全局变量了,这种就是闭包了
def account_create(initial_amount=0):
def atm(num,deposit=True):
nonlocal initial_amount #这条句子定义后,后续可以在修改变量
if deposit:
initial_amount+=num
print(f"存款+{num},账户余额{initial_amount}")
else:
initial_amount-=num
print(f"存款-{num},账户余额{initial_amount}")
return atm
fn=account_create()
fn(100) #存款+100,账户余额100
fn(200) #存款+200,账户余额300
#闭包的优点 无需要定义全局变量就可以通过函数,持续的访问修改某个值,闭包使用的变量在于函数内,难被错误的调用修改
#缺点,由于内部持续引用外包函数的值,所以会导致内存空间不足,一直占用内存
# 装饰器的一般写法(闭包)
def outer(func):
def inner():
print("我要睡觉了")
func()
print("我要起床了")
return None
return inner
def sleep():
import random
import time
print("睡眠中。。。")
time.sleep(random.randint(1, 5))
return None
fn = outer(sleep)
fn()
# 装饰器的快捷写法
def outer(func):
def inner():
print("我要睡觉了")
func()
print("我要起床了")
return None
return inner
@outer
def sleep():
import random
import time
print("睡眠中。。。")
time.sleep(random.randint(1, 5))
return None
sleep()