python基础之编程进阶
高级变量、面向对象、模块的使用、异常处理、Json
一、高级变量类型
1、列表 list 可变
创建空列表： list = []
转列表：l = list()
列表添加元素：l.append(a) , 列表末尾添加一个元素
列表添加元素：l.extend([a,b]) , 列表添加一个列表
列表添加元素：l.insert(index, 元素)
查询列表元素索引：l.index(元素) 指定起始位置l.index(元素, start, end)
根据索引查看值：l[1]
删除列表元素: l.remove(元素) 找到
弹出列表元素：l.pop(index) 默认最后一个 -1
删除列表： del l
清空列表: l.clear()
列表的截取(切片): l[0:3:-2] 左闭右开 第三位为步长
倒序:l[::-1]
列表的排序：l.sort() l.sort(reverse=True)
l1 = sorted(l) 返回一个新列表
2、元组 tuple 不可变
tuple = ()
创建元组：t = (1, 2) t = 1, 2
元组的增加：拼接 t = (1, 2) + (2, 3)
3、字典 dict 可变 无序
d = {}
字典的创建 d = {'键'：值， '键2'：值3} 关键字带引号
d = dict(one=1， two=2, c=3) 关键字不带引号
查找字典：查找键d.keys() 查找值d.values() 查找键值对：d.items
查找键返回值d.get('key')
查找键返回值 d['key'] 还可以赋值，无键的时候会报错
字典增加 ： d.update(one =1)
setdefault(key, default=None)
d = dict(one =1)
d.default('one') d.default('three') 有的键就用原来的值，没有的赋值default
字典的删除：pop('key')
随机删除：popitem()
4、集合 set 有去重的作用
创建集合：s = {1, 2}
set(l)
查找集合: 可以用in 判断
添加集合: add(obj)
删除集合：remove(obj)
合并集合：union(s1, s2)
二、面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
1、类
定义类
class 类名：
属性
def 方法(self)：
2、实例
实例 = 类()
类创建对象的过程就是实例化
3、共有和私有
public ：实例创建后 属性和方法都能 .出来
private ： python中的私有用的__ ,不能点出来，可以定义public 的方法 return self.__属性查看
4、__init__()和__del__()方法
魔术方法
构造函数 __init__() 实例化对象时候优先调用
析构函数 __del__() 对象生命周期销毁时，调用
5、继承
继承是类与类之间的关系，父类与子类
issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
class A(object):
def __init__(self):
self.x = 1
class B(A):
def __init__(self):
super(B,self).__init__()
self.x = self.x +1
print(self.x)
b = B()
一个子类可以继承多个父类，多重继承
6、多态
子类继承父类的属性，又更改一些方法和属性
多态：指的是以类事物有多种形态，如一个抽象类有多个子类，多态的概念依赖于继承
class Animal:
def run(self):
raise AttributeError('子类必须实现这个方法')
class People(Animal):
def run(self):
print('人正在走')
class Pig(Animal):
def run(self):
print('猪正在散步')
class Dog(Animal):
def run(self):
print('狗正在走')
people = People()
pig = Pig()
dog = Dog()
people.run()
pig.run()
dog.run()
多态性：指具有不同功能的函数可以使用相同的函数名，这样可以用一个函数名调用不同内容的函数（如向不同的对象发送同一条消息，不同的对象接受时会执行不同的行为）。简单来说，就是一种调用方式，产生不同的执行效果。
# 多态性：一种调用方式，不同的执行效果（多态性）
class Animal:
def run(self):
raise AttributeError('子类必须实现这个方法')
class People(Animal):
def run(self):
print('人正在走')
class Pig(Animal):
def run(self):
print('猪正在散步')
class Dog(Animal):
def run(self):
print('狗正在走')
people = People()
pig = Pig()
dog = Dog()
# 多态性：定义统一的接口
def func(obj): # obj这个参数没有类型限制，可以传入不同类型的值
obj.run() # 调用的逻辑都一样，执行的结果却不一样
func(people)
func(pig)
func(dog)
三、模块的使用
1、模块的定义
容器：数据封装
函数：语句封装
类：方法和属性封装
模块：类 语句 数据封装起来，也就是程序，每一个模块都以.py结尾
2、导入模块 ： import 或者 from xxx import xxx import xxx as x
import sys
sys.path # 显示路径
添加路径 path.sys.append('要导入的绝对路径')
安装模块：pip install xxxx
四、异常处理
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
...
>>> divide(2, 1)
result is 2
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
raise 抛出异常
with 语句使得文件之类的对象可以 确保总能及时准确地进行清理。
with open("myfile.txt") as f:
for line in f:
print(line)
五、Json
import json
data = {'name':'nanbei','age':18}
# 将Python对象编码成json字符串
print(json.dumps(data))
import json
data = {'name':'nanbei','age':18}
# 将Python对象编码成json字符串
# print(json.dumps(data))
# 将json字符串解码成Python对象
a = json.dumps(data)
print(json.loads(a))
import json
data = {
'nanbei':'haha',
'a':[1,2,3,4],
'b':(1,2,3)
}
with open('json_test.txt','w+') as f:
json.dump(data,f)
with open('json_test.txt','r+') as f:
print(json.load(f))
import json
# dumps可以格式化所有的基本数据类型为字符串
data1 = json.dumps([]) # 列表
print(data1, type(data1))
data2 = json.dumps(2) # 数字
print(data2, type(data2))
data3 = json.dumps('3') # 字符串
print(data3, type(data3))
dict = {"name": "Tom", "age": 23} # 字典
data4 = json.dumps(dict)
print(data4, type(data4))
with open("test.json", "w", encoding='utf-8') as f:
# indent 超级好用，格式化保存字典，默认为None，小于0为零个空格
f.write(json.dumps(dict, indent=4))
json.dump(dict, f, indent=4) # 传入文件描述符，和dumps一样的结果
import json
dict = '{"name": "Tom", "age": 23}' # 将字符串还原为dict
data1 = json.loads(dict)
print(data1, type(data1))
with open("test.json", "r", encoding='utf-8') as f:
data2 = json.loads(f.read()) # load的传入参数为字符串类型
print(data2, type(data2))
f.seek(0) # 将文件游标移动到文件开头位置
data3 = json.load(f)
print(data3, type(data3))
dumps(obj,skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
函数作用: 将Python对象转变成JSON对象，便于序列化内存/文件中。
参数：
skipkeys: 如果为True的话，则只能是字典对象，否则会TypeError错误, 默认False
ensure_ascii: 确定是否为ASCII编码
check_circular: 循环类型检查，如果为True的话
allow_nan: 确定是否为允许的值
indent: 会以美观的方式来打印，呈现，实现缩进
separators: 对象分隔符，默认为,
encoding: 编码方式，默认为utf-8
sort_keys: 如果是字典对象，选择True的话，会按照键的ASCII码来排序
SON反序列化为类对象或者类的实例，使用的是loads()方法中的object_hook参数：
代码示例：
import json
# 定义一个员工类
class Employee(object):
def __init__(self,name,age,sex,tel):
self.name=name
self.age=age
self.sex=sex
self.tel=tel
# 实例化一个对象
emp = Employee('kongsh',18,'female',13123456789)
# 定义JSON转换Python实例的函数
def jsonToClass(emp):
return Employee(emp['name'], emp['age'], emp['sex'], emp['tel'])
# 定义一个json字符串（字典）
json_str = '{"name": "kongsh", "age": 18, "sex": "female", "tel": 13123456789}'
emp = json.loads(json_str, object_hook=jsonToClass)
print (emp)
print(emp.name)
————————————————
浙公网安备 33010602011771号