python基础篇，这些你知道吗?

梳理，熟悉

基础打牢了，才能走的更远。

列表可以修改，而元组不行，但是元组里的列表可以
局部和全局变量，要想更改全局变量的值，可以加个global声明
split 切片，只针对字符串
remove:删除的是具体字符串的值
pop:给出索引值删除对应的字符串
sort:排序
占位符：f’{占位符1}，{占位符2}’，{salary:8}:没有8个字符前面补空格
循环遍历：拿到数据 split(’,’)[-1]
列表推导式：
​ lists=[2,3,5,8]
​ [num**2 for num in lists]
面试常常会被问到，算法
冒泡排序：

arr = [2,6,3,55,48,225]
#定义长度
lens = len(arr)
#获取数据
for params in range(lens-1,0,-1):
    #一个一个拿
    for i in range(params):
        if arr[i]>arr[i+1]:
            arr[i],arr[i+1]=arr[i+1],arr[i]
            
print(arr)
	

文件读取：

open，内置函数，打开文件
打开文件：参数

file:对应要打开的文件路径
mode: 打开文件的模式，r（读取）,w（写入），a(追加内容)
encoding:字符编码格式
举例：f=open(‘text.txt’,‘w’,encoding=‘utf-8’)
​ f.close()

注意：w写入文件，之前的内容全部会被删除
通过获取文件，内容，可以进行切片，拿到想要的内容
content = f.read()
f.close()
name=content.split(’: ')[0] #获取拆分后，0的内容
read ：里面有参数，可以指定数，需要读几个数

使用with 语句就可以不用调用close方法关闭

with open('test.txt') as f:
    listline = f.read()
    for line in listline:
        print(line)

写入文件：

一般不会直接就会保存到文件中，会先写入一个缓存区中
如果想直接保存到文件中：

with open(test.txt,'w',encoding='utf-8') as f:
    f.write("哈哈哈哈哈")
    f.flush
    
import time
time.sleep(30)

模块的概念

不同的代码文件，实现了不同的功能模块

import /from import
模块的导入会产生个字不同的对象，而不是共用一个对象
如果需要改变，可以将对象存储在列表中

包

包目录下有__ init __.py:才认为这是一个python 包

项目文件夹下包含__ init __.py，并且有很多子文件夹中包含很多模块

库

开发某个模块，给其他模块进行调用

标准库

内置类型有：int、float、str、list、tuple

需要import 调用才能调用内部方法

sys, os, time, datetime, json，random

其他的库：

直接使用第三方库，pip一键下载，下载完成就可以直接导入使用了

IDE：

集成开发软件,高效的开发项目代码
pycharm,vscode

字典

键值对，通过键，就能查到键中所有值的信息

键：数字、字符串（唯一的）

值：任意类型的对象

判断字典是否存在某个key

a in var:存在为true,不存在为false

访问字典中所有的元素：

members = {
    'a'  : 13 ,
    'b'  : 12 ,
    'c'  : 15 ,
}

for account,level in members.items():
    print (f'键:{account}, 值:{level}')

字典中每个元素就是键值组成的表：

[('a', 13), ('b', 12), ('c', 15)]

clear: 清空字典中的所有元素
update:合并两个字典

len(字典名):输出字典元素的个数

自定义类

@staticmethod ：静态方法

类名.静态方法中定义的方法名（），进行调用

实例对象.类名（），就可以调用类中的属性和方法了

类属性是共同的特征

如果定义不同特征，就可以在方法中进行定义和修改

解释性语言------创建实例------进行调用

__ init __(self):

子类：自动用于父类的所有属性和方法

注意：子类中初始化代码和父类的初始化代码相同，需要在子类定义的初始化方法中加上父类定义的初始化方法

如果子类没有定义初始化方法，python 解释器会自动调用父类的初始化方法，如果子类中定义了初始化方法，就只会调用子类中的初始化方法，而不会调用父类中的初始化方法

创建了实例对象，就能访问实例属性了

如何是通过类名来访问属性，就只会访问类属性而不会访问实例属性

class Car:
    brand = '奔驰'
    name = 'Car'

    def __init__(self):
        # 可以通过实例访问到类属性
        print(self.brand)
        
        # 定义实例属性和类属性重名
        self.name = 'benz car'

c1 = Car()

print(f'通过实例名访问name：{c1.name}')				#benz car
print(f'通过类名  访问name：{Car.name}')			 #Car

父类和子类之间的调用

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    def __init__(self,color,engineSN):
        self.color  =  color  # 颜色
        self.engineSN = engineSN # 发动机编号
    
    def changeColor(self,newColor):
        self.color = newColor

class Benz2016(BenzCar):
    price   = 580000
    model   = 'Benz2016'   


class Benz2018(BenzCar):
    price   = 880000
    model   = 'Benz2018'     

    def __init__(self,color,engineSN,weight):
        # 先调用父类的初始化方法
        BenzCar.__init__(self,color,engineSN)
        #写法二：super().__init__(self,color,engineSN)
        self.weight = weight # 车的重量
        #初始化一个实例变量
        self.oilweight = 0  # 油的重量
    
    # 加油
    def fillOil(self, oilAdded):
        self.oilweight +=  oilAdded 
        self.weight    +=  oilAdded

car2 = Benz2018('blue','111135545988',1500)   
print (car2.oilweight)		#0
print (car2.weight)			#1500
car2.fillOil(50) 			
print (car2.oilweight)		#50
print (car2.weight)			#1550

打印自定义类的对象

class BenzCar:
    brand   = '奔驰'

    def __init__(self,color='black'):
        self.color = color

    def __repr__(self):
        return f"BenzCar object: brand = 奔驰, color = {self.color}"

# 打印实例对象
print(BenzCar())

结果：

BenzCar object: brand = 奔驰, color = black

异常

try:
    
except Exception as e:
    print('未知异常',e)

​

局部变量和全局变量

global 在函数内声明，一个变量，声明他是全局变量

可变参数

studentinfo={
    '张三':23,
    '李四':25,
    '王五':20,
    '赵六':21,
    '阿七':18,
}

def getage(*students):
    for student in students:
        print(f'姓名为{student},年龄为{studentinfo[student]}')
getage('张三','赵六')

函数内的参数名前面加了个*号，这时python 解释器会创建一个tuple 存储传进来的变量，例如，张三，赵六

在调用函数的时候，传入参数前面加上星号，参数展开

onebatch = ['张飞', '典韦', '关羽']
getage(*onebatch)
#等价于
getage =  (onebatch[0], onebatch[1], onebatch[2])

关键字参数：

**：说明参数变量的值是一个字典

python解释器会创建一个dict(字典)，赋值这个参数变量，放在dict中

def addstudents(table,**students):
    for name,age in students.items():
        table[name]=age
        
table1={}
addstudents(table1,张三=20,李四=30)