Python开发-对象操作
1.1、对象操作
- 有序性
list、tuple、dict、set几种数据类型，列表和元组可以使用索引查找，所以是有序的，集合和字典（依靠键值查找）是无序的；
列表和元组的索引都是从0 开始，-1 为最后一个元素；
1.1.1、列表使用
- 元素添加、删除、插入、清空
>>> list_c=["a","b","c","d","e"]
>>> list_c.append("f")
>>> print(list_c)
['a', 'b', 'c', 'd', 'e', 'f']
>>> del list_c[2]
>>> print(list_c)
['a', 'b', 'd', 'e', 'f']
>>> list_c.insert(3,"m")
>>> print(list_c)
['a', 'b', 'd', 'm', 'e', 'f']
>>> list_c.clear()
>>> print(list_c)
[]
- 求列表最大、最小、长度
list_a=[1,2,3,4,5]
>>> print("list_a的最大值为：%d，最小值为：%d，长度为：%d"%(max(list_a),min(list_a),len(list_a)))
list_a的最大值为：5，最小值为：1，长度为：5
>>>
- list(tuple)：将元组转化为列表
>>> tup_a=("a","b","c","d","e")
>>> list_b=list(tup_a)
>>> type(list_b)
<class 'list'>
>>> print(list_b)
['a', 'b', 'c', 'd', 'e']
>>>
- 列表转字符串
column_list = [object_name,object_type,object_comments,object_ddl,creationdate,creator,modificationdate,modifier,sc_sj]
"."join(column_list)
- 列表反转
>>>
>>> list_a = [11,22,33,55,33,22,11,99]
>>> list_a[::-1]
[99, 11, 22, 33, 55, 33, 22, 11]
>>> list_a[-1::-1]
[99, 11, 22, 33, 55, 33, 22, 11]
说明：list[::-1] 和 list[-1::-1] 的结果一致，都是将列表元素反转；
这里有三个参数，第一个参数为 -1 表示最后一个元素，第二个元素为空表示该元素至于序列最后，第三个参数为 -1 表示步长为反向；
- 2个列表合并
list_a.extent(list_b)
或者
list_a + list_b
说明；将 列表 list_b 的值合并到列表 list_a 中；
1.1.2、元组使用
- 求元组最大、最小、长度
tup_a=(1,2,3,4,5)
>>> print("tup_a的最大值为：%d，最小值为：%d，长度为：%d"%(max(tup_a),min(tup_a),len(tup_a)))
tup_a的最大值为：5，最小值为：1，长度为：5
>>>
- tuple(list)：将列表转化为元组
>>>
>>> list_b=("a","b","c","d","e")
>>> tup_b=tuple(list_b)
>>> type(tup_b)
<class 'tuple'>
>>> print(tup_b)
('a', 'b', 'c', 'd', 'e')
>>>
1.1.2、字典使用
- 元素修改、添加、删除、清空
>>>
>>> dic_a={"a":"111","b":"222","c":"333","d":"444"}
>>> dic_a["b"]="777"
>>> print(dic_a)
{'a': '111', 'b': '777', 'c': '333', 'd': '444'}
>>> dic_a["f"]="999"
>>> print(dic_a)
{'a': '111', 'b': '777', 'c': '333', 'd': '444', 'f': '999'}
>>>
>>> del dic_a["a"]
>>> print(dic_a)
{'b': '777', 'c': '333', 'd': '444', 'f': '999'}
>>> dic_a.clear()
>>> print(dic_a)
{}
>>>
- 求字典长度
>>> dic_a={"a":"111","b":"222","c":"333","d":"444"}
>>> len(dic_a)
4
>>>
dict 在查找不存在的 key时，会抛出异常；为了避免异常，可以使用
dict.get(key,default)的方法；
-
dict.get(key,default) -
2个字典合并
dict_a.update(dict_b)
说明：将字典 dict_b 的键、值合并到字典 dict_a 中；
1.1.3、集合使用
- 元素的添加、删除、清空
str_setC=set(("aaa","bbb","ccc","ddd"))
str_setC.add("MMM") #集合元素添加
str_setC.remove("aaa") #集合元素删除
print("str_setC：",str_setC)
- 元素删除的方法二：
str_setC.discard("aaa")
说明：
- 集合是无序的，所以无法按照索引操作集合对象
>>> set_a={"aaa","bbb","ccc","ddd","eee"}
>>> set_a[3]="mmm"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment
>>>
1.1.4、字符串
1.1.4.1、repr() 使用
输出9*9口诀
>>>
>>> for x in range(1,10):
... for y in range(1,10):
... print(repr(x),"*",repr(y),"=",repr(x*y).rjust(2),end=" "*3)
... print()
...
1 * 1 = 1 1 * 2 = 2 1 * 3 = 3 1 * 4 = 4 1 * 5 = 5 1 * 6 = 6 1 * 7 = 7 1 * 8 = 8 1 * 9 = 9
2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 4 * 5 = 20 4 * 6 = 24 4 * 7 = 28 4 * 8 = 32 4 * 9 = 36
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 6 * 7 = 42 6 * 8 = 48 6 * 9 = 54
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 7 * 8 = 56 7 * 9 = 63
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 8 * 9 = 72
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
>>>
1.1.4.2、str.formate 使用
强调：str.formate 在字符串的替换中可以直接使用，无需配合print；
>>> str_a="student name={},age={}".format("jact",13)
>>> print(str_a)
student name=jact,age=13
>>>
>>>
A：无序参数替换
>>> print("name of dog is {},age of dog is {}".format("luka",3))
name of dog is luka,age of dog is 3
>>>
B：关键字参数替换
>>>
>>> print("name of dog is {name},age of dog is {age}".format(name="luka",age=3))
name of dog is luka,age of dog is 3
>>>
C：位置参数替换
>>>
>>> print("the first name is {2},the second name is {1},the third name is {0}".format("Jack","luyisi","Marry"))
the first name is Marry,the second name is luyisi,the third name is Jack
>>>
1.1.4.3、f-string函数
>>> name="jack"
>>> age=11
>>> str_a=f"the real name of boy is {name},age is {age}"
>>> print(str_a)
the real name of boy is jack,age is 11
>>>
说明：使用 f 加到 string 左边，字符串中存在 {variable}时，变量的值将被替换为实际值；
1.1.4.4、string.encode
v_bytes=v_string.encode(encoding="utf8")
说明：将字符串转换为 字节对象；
1.1.4.5、bytes.decode
v_string=bytes.decode(encoding="utf8")
说明：将字节对象转换为字符串；
1.1.5、对象拷贝
对象拷贝分为直接赋值、浅拷贝、深拷贝；
-
直接赋值
即对象的引用，2个变量指向同一对象； -
浅拷贝
拷贝父对象，不会拷贝对象的内部的子对象，即新的对象和父对象里的子对象指向同一对象； -
深拷贝
copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
>>> list_f = [11,22,[33,44],55]
>>>
>>> list_b = list_f
>>> list_c = list_f.copy()
>>> list_b,list_c
([11, 22, [33, 44], 55], [11, 22, [33, 44], 55])
>>>
>>>
>>> import copy
>>> list_d=copy.deepcopy(list_f)
>>> list_d
[11, 22, [33, 44], 55]
>>>
操作父类对象的一级元素和一级元素的子元素，观察新生产的对象 list_b、list_c、list_d的序列内容变化；
- 操作父对象list_f 直接元素
>>> list_f.append(66)
>>> list_f
[11, 22, [33, 44], 55, 66]
>>> list_b
[11, 22, [33, 44], 55, 66]
>>> list_c
[11, 22, [33, 44], 55]
>>> list_d
[11, 22, [33, 44], 55]
>>>
结论：list_f父类对象新增元素，list_b为直接赋值，所以序列内容同样更改；List_c为浅拷贝，一级元素和父类对象不共享，所以不会更改；list_d为深度拷贝，和父类对象完全独立，所以序列内容不更改；
- 操作父类对象list_f 元素的子对象
>>>
>>> list_f[2].append(77)
>>> list_f
[11, 22, [33, 44, 77], 55, 66]
>>> list_b
[11, 22, [33, 44, 77], 55, 66]
>>> list_c
[11, 22, [33, 44, 77], 55]
>>> list_d
[11, 22, [33, 44], 55]
>>>
>>>
结论：list_f父类对象新增元素，list_b为直接赋值，所以序列内容同样更改；List_c为浅拷贝，元素的子对象和父类对象共享，所以同步更改；list_d为深度拷贝，和父类对象完全独立，所以序列内容不更改；
1.1.6、内存共用
- 对象3要素
python中对象包括3要素：id(身份标识)、type(类型标识)、value(对象值)；
对象3要素与3个内置函数的联系：Id&id()、Type&type()、Value&str()；
约定认知：将值相同的对象理解为 “相等”，将 id()相同的对象理解为“相同”；
- 特殊策略
常规：每个对象被创建时就会确定其Id标识，也就是给它分配内存地址。通常新对象的内存地址也是新的，会从未分配的可用地址中取。
特殊：为了提高内存利用效率，对于一些常用的对象，如一些数值较小的数值对象、布尔值对象、None对象、较短的字符串对象等等，python采取共用对象内存的分配策略。
现象一：
>>>
>>> list_a=["aa","bb","cc",44]
>>> id(list_a)
2378731938752
>>> id(list_a.append(55))
140711091313880
>>> list_a.append(55)
>>> id(list_a)
2378731938752
>>>
现象：step_3 得到的列表的id值和实际不同；
解释：list.append(obj)没有返回值，所以实际得到的是 None的内存地址；
>>>
>>> id(None)
140711091313880
>>>
如下如何解释？
现象二：
>>>
>>> n_1=2018
>>> n_2=2018
>>> id(n_1)==id(n_2)
False
>>>
>>>
>>> n_3,n_4=2018,2018
>>> id(n_3)==id(n_4)
True
>>>
Python中，对于整数对象，如果其值处于[-5,256]的闭区间内，则值相同的对象是同一个对象。
Python中，字符串使用Intern机制实现内存地址共用，长度不超过20，且仅包括下划线、数字、字母的字符串才会被intern；涉及字符串拼接时，编译期优化结果会与运行期计算结果不同。
1. 2、对象遍历
1.2.1、推导式
序列推导式可以加 if 条件，但是不能加 else；
1）列表推导式
语法格式：
[out_exp_res for out_exp in input_list]
[out_exp_res for out_exp in input_list if condition]
实现代码：
>>>
>>> list_a=['aaa','bbb','ccc','ddd','eee']
>>> list_b=[x.upper() for x in list_a]
>>> print(list_b)
['AAA', 'BBB', 'CCC', 'DDD', 'EEE']
>>>
2） 集合推导式
语法格式：
{ expression for item in Sequence }
{ expression for item in Sequence if conditional }
实现代码：
>>>
>>> set_a=set((2,4,6,8,10))
>>> set_b={x**2 for x in set_a}
>>> print(set_b)
{64, 100, 4, 36, 16}
>>>
3）字典推导式
语法格式：
{ key_expr: value_expr for value in collection }
{ key_expr: value_expr for value in collection if condition }
实现代码：
>>>
>>> list_a=["aaa","bbb","ccc","ddd"]
>>> dict_a={x:x.upper() for x in list_a}
>>> print(dict_a)
{'aaa': 'AAA', 'bbb': 'BBB', 'ccc': 'CCC', 'ddd': 'DDD'}
>>>
4）元组推导式
语法格式：
(expression for item in Sequence )
(expression for item in Sequence if conditional )
实现代码：
在这里插入代码片
说明：元组推导式返回的结果是一个生成器对象，可以使用 tuple()将生成器转换为元组；
1.2.2、字典遍历
- A：按照 key、value遍历
>>> dict_c={"name_1":"china","name_2":"englist","name_3":"japan","name_4":"astru"}
>>> for k,v in dict_c.items():
... print(k,v)
...
name_1 china
name_2 englist
name_3 japan
name_4 astru
>>>
- B：按照key遍历
>>>
>>> dict_c={"name_1":"china","name_2":"englist","name_3":"japan","name_4":"astru"}
>>> for i in dict_c.keys():
... print(i,dict_c[i])
... else:
... print("字典元素遍历结束!")
...
name_1 china
name_2 englist
name_3 japan
name_4 astru
字典元素遍历结束!
>>>
- C：按照 index、value遍历
>>> dict_c={"name_1":"china","name_2":"englist","name_3":"japan","name_4":"astru"}
>>> for i,v in enumerate(dict_c):
... print(i,v)
...
0 name_1
1 name_2
2 name_3
3 name_4
>>>
D：按照 key 遍历
dict_0 = {"aa":"AA","bb":"BB","cc":"CC","dd":"DD","ee":"EE"}
for x in dict_0:
print(x)
# 输出结果：
aa
bb
cc
dd
ee
Process finished with exit code 0
说明：此处直接使用该种方式，获取的元素是字段的 key 集合；
1.3、特殊对象
1.3.1、迭代器
迭代器：一种可以记住集合元素遍历位置的对象，包含两个基本的方法：iter() 和 next()。
- 迭代是访问集合元素的一种方式，迭代器可以记住遍历的位置的对象。
- 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束；迭代器只能往前不会后退。
- 迭代器有两个基本的方法：iter() 和 next()。
- 字符串，列表或元组对象都可用于创建迭代器：
1）for循环输出
>>>
>>> list_b=["aaa","bbb","ccc","ddd","eee"]
>>> l_it=iter(list_b)
>>> for x in l_it:
... print(x)
...
aaa
bbb
ccc
ddd
eee
>>>
2）while循环输出
import sys
list_b=["aaa","bbb","ccc","ddd","eee"]
l_it=iter(list_b)
while(True):
try:
print(next(l_it))
except StopIteration:
sys.exit()
3）stopIteration异常
class MyClassH:
def __iter__(self):
self.b=5
return self
def __next__(self):
if self.b <= 20:
x=self.b
self.b+=1
return x
else:
raise StopIteration
myClassa = MyClassH()
itmyClassH = iter(myClassa)
for x in itmyClassH:
print(x)
1.3.2、生成器
生成器：在 Python 中使用了 yield 的函数被称为生成器（generator），生成器是一个返回迭代器的函数，或者说生成器就是一个迭代器。
对象遍历可以如标题 1.2.1 中的 while True 循环输出一样，也可以使用 for 循环一个个输出；
生成器代码：
def loopGener():
i = 0
while i < 10:
i +=1
yield i
1.3.3、装饰器
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
======================================= over =======================================
上一篇：Python—1、基础篇
下一篇：Python—3、函数篇
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
