python基础
python基础
python数据结构
1. 列表
1）append() 增加列表项
#!/usr/bin/python3
#_*_coding:utf-8_*_
list1=["google","zhihu","newbie"]
print("更新前列表：",list1)
list1.append("baidu")
print("更新后列表：",list1)
>>输出：
更新前列表： ['google', 'zhihu', 'newbie']
更新后列表： ['google', 'zhihu', 'newbie', 'baidu']
2）del 删除列表项
#!/usr/bin/python3
list1=["google","zhihu","newbie"]
print("删除前列表：",list1)
del list1[2]
print("删除后列表：",list1)
>>输出：
删除前列表： ['google', 'zhihu', 'newbie']
删除后列表： ['google', 'zhihu']
3）列表操作符
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
4）列表拼接
#!/usr/bin/python3
list1=["google","zhihu","newbie"]
print("拼接前列表：",list1)
list1+=[1,2,3,4,5]
print("拼接后列表：",list1)
>>输出：
拼接前列表： ['google', 'zhihu', 'newbie']
拼接后列表： ['google', 'zhihu', 'newbie', 1, 2, 3, 4, 5]
5）列表嵌套
#!/usr/bin/python3
list1=['a','b','c']
list2=[1,2,3]
x=[list1,list2]
print("嵌套列表：",x)
print(x[0])
print(x[1])
>>输出：
嵌套列表： [['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
[1, 2, 3]
6）列表比较（operator模块）
- operator是python内置的运算函数
operator.lt(a, b) #a<b
operator.le(a, b) #a<=b
operator.eq(a, b) #a==b
operator.ne(a, b) #a!=b
operator.ge(a, b) #a>=b
operator.gt(a, b) #a>b
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)
operator.lt(a, b) 与 a < b 相同， operator.le(a, b) 与 a <= b 相同，operator.eq(a, b) 与 a == b 相同，operator.ne(a, b) 与 a != b 相同，operator.gt(a, b) 与 a > b 相同，operator.ge(a, b) 与 a >= b 相同。
#!/usr/bin/python3
import operator
a=[1,2]
b=[2,3]
c=[2,3]
print(operator.eq(a,b))
print(operator.__eq__(a,b))
print(operator.eq(b,c))
print(operator.__eq__(b,c))
print(operator.lt(a,b))
>>输出：
False
False
True
True
True
7）列表的函数
| 序号 | 函数 |
|---|---|
| 1 | len(list)列表元素个数 |
| 2 | max(list)返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq)将元组转换为列表 |
Python包含以下方法:
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj)在列表末尾添加新的对象 |
| 2 | list.count(obj)统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj)从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj)将对象插入列表中指定的索引位置 |
| 6 | list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj)移除列表中某个值的第一个匹配项 |
| 8 | list.reverse()反向列表中元素，对列表中的值反向排序 |
| 9 | list.sort( key=None, reverse=False)对原列表进行永久排序 |
| 10 | sorted(list,reverse=False)对列表临时排序 |
| 11 | list.clear()清空列表 |
| 12 | list.copy()复制列表 |
#!/usr/bin/python3
#列表的函数
list1=[1,2,3,4]
list2=["a","b","c"]
#列表中追加新的元素append
list1.append(4)
print(list1)
#列表中增加新的序列extend
list1.extend(list2)
print(list1)
#将对象插入列表中指定的索引位置insert
list1.insert(0,"jiaxing")
print(list1)
#统计列表中某个元素出现的个数count
print(list1.count(4))
#找出列表中第一个匹配项的索引位置索引index
print(list1.index(4))
#移除列表中的一个值（默认是最后一个元素），并返回该值pop
print(list1.pop(0))
#移除列表中某个值的第一个匹配项remove
list1.remove(4)
print(list1)
#对列表中的值反向排序reverse
list1.reverse()
print(list1)
#对列表进行排序sort
list2.sort() #默认升序
print(list2)
list2.sort(reverse=True) #reverse=True为降序
print(list2)
#清空列表clear
list1.clear()
print(list1)
#拷贝列表copy
list1=list2.copy()
print(list1)
2. 元组
- 元组中的值不允许被修改和删除
#!/usr/bin/python3
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
- 可以使用del删除整个元组
#!/usr/bin/python3
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
关于元组是不可变的
- 所谓元组的不可变指的是元组所指向的内存中的内容不可变。
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g' # 不支持修改元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup) # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800 # 内存地址不一样了
- 从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
元组内置函数
| 序号 | 方法及描述 | 实例 |
|---|---|---|
| 1 | len(tuple) 计算元组元素个数。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> |
| 2 | max(tuple) 返回元组中元素最大值。 | >>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> |
| 3 | min(tuple) 返回元组中元素最小值。 | >>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> |
| 4 | tuple(iterable) 将可迭代系列转换为元组。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') |
3. 字典
1）删除字典
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
2）字典键的特性
- 不允许同一键值出现两次，如果同一键值被赋予两次值，则后一个会被记住
- 键必须是不可变的，所以可以是字符串、数字、元组，而列表不行
3）字典的函数
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear()删除字典内所有元素 |
| 2 | dict.copy()返回一个字典的浅复制 |
| 3 | dict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| 5 | key in dict如果键在字典dict里返回true，否则返回false |
| 6 | dict.items()以列表返回一个视图对象 |
| 7 | dict.keys()返回一个视图对象 |
| 8 | dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict1.update(dict2)把字典dict2的键/值对更新到dict里 |
| 10 | dict.values()返回一个视图对象 |
| 11 | pop(key[,default])删除字典 key（键）所对应的值，返回被删除的值。 |
| 12 | popitem()返回并删除字典中的最后一对键和值。 |
字典直接赋值和copy的区别
#字典的函数
dict1={"user":"jiaxing","sex":"man","num":[1,2,3]}
dict2=dict1 # 浅拷贝: 引用对象
dict3=dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
dict1['user']="supershy"
dict1['num'].remove(1)
print(dict1)
print(dict2)
print(dict3)
>>输出：
{'user': 'supershy', 'sex': 'man', 'num': [2, 3]}
{'user': 'supershy', 'sex': 'man', 'num': [2, 3]}
{'user': 'jiaxing', 'sex': 'man', 'num': [2, 3]}
- 实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。
dict.fromkeys()
- Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
seq=('user','name','sex')
val='2'
dict1=dict.fromkeys(seq)
dict2=dict.fromkeys(seq,val)
print(dict1)
print(dict2)
>>输出：
{'user': None, 'name': None, 'sex': None}
{'user': '2', 'name': '2', 'sex': '2'}
dict.get()
- 返回指定键的值，如果键不在字典中返回 default 设置的默认值
#返回指定键的值，如果键不在字典中返回 default 设置的默认值
dict1={'name':'jiaxing','age':22}
print(dict1.get('name','没有这个键'))
print(dict1.get('sex','没有这个键'))
#嵌套字典使用
tinydict = {'Name': 'Runoob', 'Age': 27, 'student':{'stu_name':'jiaxing'}}
print(tinydict.get('student',{}).get('stu_name'))
dict.items()、dict.keys()、dict.values()
- Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对。
- dict.keys()、dict.values()和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
- 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
- 我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
dict1={'name':'jiaxing','age':22}
print(dict1.items())
print(dict1.keys())
print(dict1.values())
>>输出：
dict_items([('name', 'jiaxing'), ('age', 22)])
dict_keys(['name', 'age'])
dict_values(['jiaxing', 22])
dict.setdefault()
- Python 字典 setdefault() 方法和 get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
dict1={'name':'jiaxing','age':22}
print(dict1.setdefault('name'))
print(dict1.setdefault('sex',None))
print(dict1)
>>输出：
jiaxing
None
{'name': 'jiaxing', 'age': 22, 'sex': None}
dict.update()
- Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict1 里。
dict1={'name':'jiaxing','age':22}
dict2={'sex':'man','hobby':'game'}
dict1.update(dict2)
print(dict1)
>>输出：
{'name': 'jiaxing', 'age': 22, 'sex': 'man', 'hobby': 'game'}
dict.pop()
- Python 字典 pop() 方法删除字典 key（键）所对应的值，返回被删除的值。
dict1={'name':'jiaxing','age':22}
dict2={'sex':'man','hobby':'game'}
element=dict2.pop('sex')
print(element)
print(dict2)
>>输出：
man
{'hobby': 'game'}
dict.item()
- Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。
- 如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
#!/usr/bin/python3
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
# ('url': 'www.runoob.com') 最后插入会被删除
result = site.popitem()
print('返回值 = ', result)
print('site = ', site)
# 插入新元素
site['nickname'] = 'Runoob'
print('site = ', site)
# 现在 ('nickname', 'Runoob') 是最后插入的元素
result = site.popitem()
print('返回值 = ', result)
print('site = ', site)
>>输出：
返回值 = ('url', 'www.runoob.com')
site = {'name': '菜鸟教程', 'alexa': 10000}
site = {'name': '菜鸟教程', 'alexa': 10000, 'nickname': 'Runoob'}
返回值 = ('nickname', 'Runoob')
site = {'name': '菜鸟教程', 'alexa': 10000}
4）字典遍历
- key(),value(),items()
a={'name':'gaojiaxing','age':20}
#遍历key
for key in a.keys():
print(key)
#遍历value
for value in a.values():
print(value)
#遍历整体字典
for key,value in a.items():
print(f"key:{key} value:{value}")
a={'gaojiaxing':20,
'supershy':20
}
#使用集合对重复的值去重
for value in set(a.values()):
print(value)
4. 字符串
- python会将非空字符串解读为True，也可以用None作为占位符
name=''
if name:
print(name)
else:
print('no name')
age=None
if age:
print(age)
else:
print('no age')
1）字符串函数
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize()将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding='UTF-8',errors='strict')以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
| 6 | str.endswith(suffix[, start[, end]]) 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置。 |
| 7 | expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。 |
| 10 | isalnum()检查字符串是否由字母和数字组成，即字符串中的所有字符都是字母或数字。如果字符串至少有一个字符，并且所有字符都是字母或数字，则返回 True；否则返回 False。 |
| 11 | isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| 12 | isdigit()如果字符串只包含数字则返回 True 否则返回 False. |
| 13 | islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace()如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 | istitle()如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string)返回字符串长度 |
| 20 | ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower()转换字符串中所有大写字符为小写. |
| 22 | lstrip()截掉字符串左边的空格或指定字符。 |
| 23 | maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str)返回字符串 str 中最大的字母。 |
| 25 | min(str)返回字符串 str 中最小的字母。 |
| 26 | replace(old, new [, max])把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始. |
| 29 | rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip()删除字符串末尾的空格或指定字符。 |
| 31 | split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| 32 | splitlines([keepends])按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | strip([chars]) 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase()将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars="")根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper()转换字符串中的小写字母为大写 |
| 39 | zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
| 41 | format() 字符串格式化工具 |
| 42 | readline() 每次只读取一行 |
| 43 | readlines() 一次性读取文件中所有行，并返回一个列表，文件中一行代表列表中一个元素 |
#string字符串函数
str1='jiaxing'
str2='gao\njia\rxing'
str3='supershy666嘉'
str4='123'
str5='Gao'
str6='五'
str7=' '
str8='GAO'
str9='-'
str10 = "this is string example....wow!!!"
list1=['g','a','o','j','i','a','x','i','n','g']
#首字母大写capitalize
print(str1.capitalize())
#将字符串全部转换成大写upper
print(str1.upper())
#center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
print(str1.center(50,'*'))
#统计字符在字符串中出现的次数count
print(str1.count('i'))
print(str1.count('i',0,4))
#判断字符串是否以指定字符结尾endswith()
print(str1.endswith('xing'))
print(str1.endswith('xing',3,7))
#替换字符串中的\t制表符为空格expandtabs
print(str2)
print(str2.expandtabs())
print(str2.expandtabs(3))
#检测指定字符串是否在指定的范围内find()
print(str1.find('xing'))
print(str1.find('xing',5,7))
#rfind()从字符串右侧开始查找
print(str1.rfind('xing'))
print(str1.rfind('xing',5,7))
#index()和find()方法一样，只不过匹配到字符串会报异常
print(str1.index('xing'))
#print(str1.index('xing',5,7)) #会报错
#rindex()从右侧开始查找
print(str1.rindex('xing'))
#print(str1.rindex('xing',5,7)) #会报错
#检查字符串中是否都是字母或数字组成isalnum()
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
#检查字符串中是否是字母或汉字组成，有数字则返回flase，isalpha()
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
#检查字符串中是否只包含数字isdigit()
print(str1.isdigit())
print(str2.isdigit())
print(str3.isdigit())
print(str4.isdigit())
#判断字符串中是否都是小写字母islower()
print(str1.islower())
print(str4.islower())
print(str5.islower())
#检查字符串中是否只包含数字字符isnumeric()
print(str4.isnumeric())
print(str6.isnumeric())
#字符串中只包含空白则返回true，isspace()
print(str7.isspace())
#检查字符串是否是title()格式的istitle()
print(str5.istitle())
#判断字符串是否都是大写isupper()
print(str5.isupper())
print(str8.isupper())
#将字符串序列以指定字符进行拼接join(seq)
print(str7.join(str1))
print(str9.join(str1))
print(str9.join(list1))
#返回原字符串左对齐，可以指定长度+填充的符号(默认填充空格)ljust()
print(str1.ljust(50,'*'))
#返回原字符串右对齐，可以指定长度+填充的符号(默认填充空格)rjust()
print(str1.rjust(50,'*'))
#截掉字符串中左边的空格或者指定字符lstrip()
print(str1.lstrip('jia'))
#截掉字符串中右边的空格或者指定字符rstrip()
print(str1.rstrip('xing'))
#同时截掉字符串中左右边的空格或者指定字符strip()
print(str1.strip('i'))
#转换字符串中的字符maketrans(),translate()
mytab=str1.maketrans('j','x')
print(str1.translate(mytab))
#将字符串中的old转换为new，如果指定max则转换次数不超过max,replace()
print(str1.replace('i','a',1))
print(str1.replace('jia','gao'))
#将字符串分割成多个部分返回到列表中,默认以空格分割split()
print(str10.split())
print(str1.split('i'))
print(str1.split('i',1))
#以\r,\n转义字符进行切割True为显示转义字符，默认false不显示splitlines()
print(str2.splitlines())
print(str2.splitlines(True))
print(str2)
#判断字符串是否以指定字符开头，也可以指定范围内startswith()
print(str1.startswith('j'))
print(str1.startswith('x',3,6))
#将字符串中大写转换为小写，小写转化为大写swapcase()
print(str5.swapcase())
#返回指定长度的字符串，原字符串长度不够则在前面填充0输出zfill()
print(str1.zfill(50))
#检查字符串中是否只包含十进制字符isdecimal()
print(str4.isdecimal())
format / f"string" / %s % ()区别
从性能角度看，f-string 是最快的，其次是 str.format()，最后是 % 操作符。这是因为 f-string 是在运行时直接解析的，而其他两种方式需要更多的中间步骤。
从 Python 3.6 开始，引入了 f-strings，这是一种更简洁的字符串格式化方法，语法更直观
format
1）基本用法
# 括号及之内的字符（称为格式字段）被替换为传递给 str.format() 方法的对象。
s = "Hello, {}!".format("world")
print(s) # 输出: Hello, world!
2）指定位置
# 通过索引指定位置
# 花括号中的数字表示传递给 str.format() 方法的对象所在的位置。
print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
# 通过关键字指定位置
s = "{name} is {age} years old".format(name="Alice", age=30)
print(s) # 输出: Alice is 30 years old
3）格式化数字
# 浮点数格式化，指定小数点后位数
s = "The value of pi is approximately {0:.3f}".format(3.1415926)
print(s) # 输出: The value of pi is approximately 3.142
# 整数格式化，指定宽度和填充字符
s = "The number is {0:04d}".format(42)
print(s) # 输出: The number is 0042
4）对齐和填充
# 左对齐
s = "{:<10}".format("hello")
print(s) # 输出: hello
# 右对齐
s = "{:>10}".format("hello")
print(s) # 输出: hello
# 居中对齐
s = "{:^10}".format("hello")
print(s) # 输出: hello
# 指定填充字符
s = "{:*^10}".format("hello")
print(s) # 输出: **hello***
5）格式化日期
from datetime import datetime
# 格式化日期
now = datetime.now()
s = "Today is {:%Y-%m-%d %H:%M:%S}".format(now)
print(s) # 输出: Today is 2025-01-17 12:34:56
6）格式化复杂数据结构
# 格式化字典
person = {"name": "Bob", "age": 25}
s = "Name: {0[name]}, Age: {0[age]}".format(person)
print(s) # 输出: Name: Bob, Age: 25
# 格式化对象
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person = Person("Alice", 30)
s = "Name: {0.name}, Age: {0.age}".format(person)
print(s) # 输出: Name: Alice, Age: 30
7）使用 f-strings（Python 3.6+）
- 从 Python 3.6 开始，引入了 f-strings，这是一种更简洁的字符串格式化方法，语法更直观：
name = "Alice"
age = 30
s = f"Name: {name}, Age: {age}"
print(s) # 输出: Name: Alice, Age: 30
# 格式化表达式
s = f"The value of pi is approximately {3.1415926:.3f}"
print(s) # 输出: The value of pi is approximately 3.142
python 基础语法
match语句
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"
- 注意最后一个代码块：“变量名”
_被作为 通配符 并必定会匹配成功。如果没有 case 匹配成功，则不会执行任何分支。
你可以用 | （“或”）将多个字面值组合到一个模式中：
case 401 | 403 | 404:
return "Not allowed"
推导式
names=['gao','jia','xing','supershy']
#列表推导式
m=[name.upper() for name in names if len(name)>3]
print(m)
#字典推导式
dict1={key:len(key) for key in names}
print(dict1)
squ={x:x**2 for x in range(5)}
print(squ)
#集合推导式
set1={x**2 for x in range(5)}
print(set1)
set2={i for i in 'abcderf' if i not in 'abc'}
print(set2)
#元组推导式
tup1=(x for x in range(1,9))
print(tup1) #返回的是生成器对象
print(tuple(tup1)) #tuple()转换成元组值
迭代器
- 迭代器是python中最强大的功能之一，是访问集合序列的一种方式
- 迭代器对象是从集合的第一个元素开始访问，直到最后一个元素停止，迭代器只能往前不会后退
- 迭代器的两个基本方式iter()和next()
- 字符串、列表和元组对象都可用于迭代器
#迭代器
# list1=[1,2,3,4]
#iter()和next()的基本使用
# it=iter(list1)
# print(next(it))
# print(next(it))
# print(next(it))
#使用for循环遍历
# it=iter(list1)
# for i in it:
# print(i,end=',')
# #使用next()函数
# import sys
# it=iter(list1)
# while True:
# try:
# print(next(it))
# except StopIteration:
# sys.exit()
# class MyNumbers:
# def __iter__(self):
# self.a=1
# return self
# def __next__(self):
# x=self.a
# self.a+=1
# return x
# myclass=MyNumbers()
# myiter=iter(myclass)
# print(next(myiter))
# print(next(myiter))
# print(next(myiter))
class MyNumbers:
def __iter__(self):
self.a=1
return self
def __next__(self):
if self.a<=20:
x=self.a
self.a+=1
return x
else:
raise StopIteration
myclass=MyNumbers()
myiter=iter(myclass)
for i in myiter:
print(i,end=' ')
生成器yield
-
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。
然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。
调用一个生成器函数，返回的是一个迭代器对象。
def counter(n):
while n<10:
yield n
n+=1
gen=counter(0)
print(next(gen))
for i in gen:
print(i,end=' ')
import sys
def fibonacci(n):
a,b,counter=0,1,0
while True:
if counter>n:
return
yield a
a,b=b,a+b
counter+=1
f=fibonacci(10)
while True:
try:
print(next(f),end=' ')
except StopIteration:
sys.exit()
函数
特殊参数
-
强制位置参数
-
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
----------- ---------- ----------
| | |
| 位置或关键字 |
| - 仅限关键字
-- 仅限位置
函数示例
请看下面的函数定义示例，注意 / 和 * 标记：
>>> def standard_arg(arg):
... print(arg)
...
>>> def pos_only_arg(arg, /):
... print(arg)
...
>>> def kwd_only_arg(*, arg):
... print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)
第一个函数定义 standard_arg 是最常见的形式，对调用方式没有任何限制，可以按位置也可以按关键字传递参数：
>>> standard_arg(2)
2
>>> standard_arg(arg=2)
2
第二个函数 pos_only_arg 的函数定义中有 /，仅限使用位置形参：
>>> pos_only_arg(1)
1
>>> pos_only_arg(arg=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'
第三个函数 kwd_only_arg 如在函数定义中通过 * 所指明的那样只允许关键字参数。
>>> kwd_only_arg(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given
>>> kwd_only_arg(arg=3)
3
最后一个函数在同一个函数定义中，使用了全部三种调用惯例：
>>> combined_example(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given
>>> combined_example(1, 2, kwd_only=3)
1 2 3
>>> combined_example(1, standard=2, kwd_only=3)
1 2 3
>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'
下面的函数定义中，kwds 把 name 当作键，因此，可能与位置参数 name 产生潜在冲突：
def foo(name, **kwds):
return 'name' in kwds
调用该函数不可能返回 True，因为关键字 'name' 总与第一个形参绑定。例如：
>>> foo(1, **{'name': 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>
加上 / （仅限位置参数）后，就可以了。此时，函数定义把 name 当作位置参数，'name' 也可以作为关键字参数的键：
>>> def foo(name, /, **kwds):
... return 'name' in kwds
...
>>> foo(1, **{'name': 2})
True
换句话说，仅限位置形参的名称可以在 **kwds 中使用，而不产生歧义。
使用切片副本作为函数实参传递与不使切片副本传参的区别
- 不使用副本传递形参：直接操作原始数据，适用于需要修改原始对象的场景。
- 使用副本传递形参：保护原始数据不被修改，适用于需要保留原始状态的场景。
- 根据具体需求选择合适的方式，并注意浅拷贝与深拷贝的区别。
#使用副本作为函数实参传递
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design = unprinted_designs.pop()
print(f"Printing model: {current_design}")
completed_models.append(current_design)
def show_completed_models(completed_models):
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
def show_unprinted_designs(unprinted_designs):
print("\n打印pop后的unprinted_designs:")
for unprinted_design in unprinted_designs:
print(unprinted_design)
unprinted_designs=['phone case','robot pendant']
completed_models=[]
print_models(unprinted_designs[:],completed_models)
show_completed_models(completed_models)
show_unprinted_designs(unprinted_designs)
--->输出：
Printing model: robot pendant
Printing model: phone case
The following models have been printed:
robot pendant
phone case
打印pop后的unprinted_designs:
phone case
robot pendant
#不使副本传参的区别
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design = unprinted_designs.pop()
print(f"Printing model: {current_design}")
completed_models.append(current_design)
def show_completed_models(completed_models):
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
def show_unprinted_designs(unprinted_designs):
print("\n打印pop后的unprinted_designs:")
for unprinted_design in unprinted_designs:
print(unprinted_design)
unprinted_designs=['phone case','robot pendant']
completed_models=[]
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)
show_unprinted_designs(unprinted_designs)
--->输出：
Printing model: robot pendant
Printing model: phone case
The following models have been printed:
robot pendant
phone case
打印pop后的unprinted_designs:
模块创建及调用方式
创建模块
--->创建一个以.py结尾的文件,pizza.py内容如下：
def make_pizza(size,*toppings):
print(f"做一个 {size}寸的pizza,选放的调料有:")
for topping in toppings:
print(f"- {topping}")
使用创建的模块
方式一：直接导入整体模块
import pizza
pizza.make_pizza(16,'正常')
pizza.make_pizza(12,'加麻','加辣','多放芝士')
方式二：导入模块中的某个功能
from pizza import make_pizza
#直接使用模块的功能函数即可不用点号调用
make_pizza(16,'正常')
make_pizza(12,'加麻','加辣','多放芝士')
方式三：给模块功能起别名方式调用
from pizza import make_pizza as mp
mp(16,'正常')
mp(12,'加麻','加辣','多放芝士')
方式四：直接给模块起别名
import pizza as pz
pz.make_pizza(16,'正常')
pz.make_pizza(12,'加麻','加辣','多放芝士')
方式五：直接使用模块的所有功能
from pizza import *
make_pizza(16,'正常')
make_pizza(12,'加麻','加辣','多放芝士')
内置函数
lambda函数
- lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作。
x = lambda a, b : a * b
print(x(5, 6))
map()
-
map()用于将一个函数应用到可迭代对象（如列表、元组等）的每个元素上，然后返回一个包含结果的新可迭代对象。这是一种非常有效的方式来对数据进行转换。 -
map()函数的基本语法如下：map(function, iterable, ...)function：要应用于可迭代对象的函数。iterable：要进行映射操作的可迭代对象。
map()函数可以接受多个可迭代对象，但每个可迭代对象的元素数量必须一致。它将function应用于可迭代对象的对应元素，并返回一个迭代器，其中包含了所有映射后的结果。
words=["gao","jia","xing"]
a=list(map(str.title,words))
print(a)
numbers1=[1,2,3,4]
numbers2=[11,22,33,44]
b=list(map(lambda x,y:x*y,numbers1,numbers2))
print(b)
filter()
-
filter()用于筛选可迭代对象中满足指定条件的元素，然后返回一个包含筛选结果的新可迭代对象。 -
filter()函数的基本语法如下：filter(function, iterable)function：用于筛选元素的函数，该函数返回True或False。iterable：要进行筛选操作的可迭代对象。
filter()函数将function应用于iterable中的每个元素，并保留那些使function返回True的元素，生成一个包含筛选结果的迭代器。
numbers=[1,2,3,4,5,6,7,8]
a=list(filter(lambda x:x%2==0,numbers))
print(a)
words=['gao','jia','xing','supershy']
b=list(filter(lambda x: len(x)>5,words))
print(b)
reduce()
-
reduce()用于对可迭代对象中的元素进行累积操作，从左到右依次应用指定的函数，将结果汇总为一个值。这在某些情况下非常有用，例如计算累积值或查找最大/最小值。 -
reduce()函数的基本语法如下：functools.reduce(function, iterable[, initializer])function：用于累积操作的函数，该函数接受两个参数，并返回一个结果。iterable：要进行累积操作的可迭代对象。initializer（可选）：累积的初始值。
reduce()函数将function应用于iterable中的元素，从左到右依次累积，将结果传递给下一个元素。如果提供了
initializer，它将作为累积的初始值。否则，iterable的第一个元素将作为初始值。
from functools import reduce
#计算列表中元素的累积
numbers1=[1,2,3,4,5]
a=reduce(lambda x,y:x*y,numbers1)
print(a)
#找出列表中元素的最大值
numbers2=[22,44,11,66,88,3,4]
b=reduce(lambda x,y: x if x>y else y,numbers2)
print(b)
sum() 汇总计算
list1 = [1,2,3,4]
a = sum(list1)
print(a)
round() 将结果四舍五入
from math import pi
[str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
装饰器
一、装饰器的核心概念
-
函数是一等公民
Python中函数是对象，可以被赋值给变量、作为参数传递或作为返回值。例如：def greet(name): return f"Hello, {name}!" func = greet # 函数赋值给变量 print(func("Alice")) # 调用函数对象 -
闭包（Closure）
内部函数可以访问外部函数的变量，即使外部函数已执行完毕：def outer(msg): def inner(): print(msg) # 引用外部函数的变量msg return inner closure = outer("Hello") closure() # 输出: Hello
二、装饰器的基本结构
装饰器本质是一个接受函数作为参数，并返回新函数的高阶函数：
def simple_decorator(func):
def wrapper():
print("Before function call")
func()
print("After function call")
return wrapper
@simple_decorator # 语法糖，等同于 my_func = simple_decorator(my_func)
def my_func():
print("Function is called")
my_func()
# 输出：
# Before function call
# Function is called
# After function call
三、处理带参数的函数
若被装饰的函数有参数，需在内部函数中使用*args和**kwargs接收任意参数：
def decorator_with_args(func):
def wrapper(*args, **kwargs):
print("Decorator: Processing arguments")
return func(*args, **kwargs)
return wrapper
@decorator_with_args
def add(a, b):
return a + b
print(add(3, 5)) # 输出: Decorator: Processing arguments → 8
四、带参数的装饰器
若装饰器本身需要参数，需再嵌套一层函数：
def repeat(n_times): # 外层接收装饰器参数
def actual_decorator(func): # 中层接收被装饰函数
def wrapper(*args, **kwargs): # 内层处理函数调用
result = None
for _ in range(n_times):
result = func(*args, **kwargs)
return result
return wrapper
return actual_decorator
@repeat(n_times=3)
def say_hello():
print("Hello!")
say_hello()
# 输出三次: Hello!
五、保留原函数的元信息
使用functools.wraps保留原函数的__name__和文档字符串：
from functools import wraps
def preserve_metadata(func):
@wraps(func) # 关键：复制原函数信息到wrapper
def wrapper(*args, **kwargs):
"""Wrapper function's docstring."""
return func(*args, **kwargs)
return wrapper
@preserve_metadata
def sample():
"""Original docstring."""
pass
print(sample.__name__) # 输出: sample
print(sample.__doc__) # 输出: Original docstring.
六、类装饰器
通过实现__call__方法让类的实例像函数一样被调用：
class ClassDecorator:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("Class decorator: Before call")
result = self.func(*args, **kwargs)
print("Class decorator: After call")
return result
@ClassDecorator
def my_function():
print("Function execution")
my_function()
# 输出:
# Class decorator: Before call
# Function execution
# Class decorator: After call
七、装饰器的常见应用场景
- 日志记录：自动记录函数调用和参数。
- 性能测试：测量函数执行时间。
- 权限校验：检查用户权限再执行函数。
- 缓存（如
functools.lru_cache）：存储函数结果避免重复计算。
八、总结
- 装饰器的本质：通过闭包和高阶函数实现函数行为的动态修改。
- 关键点：理解
@语法糖的等价替换、参数传递的层级、元信息保留。 - 适用场景：代码复用、AOP（面向切面编程）、增强函数功能。
通过灵活运用装饰器，可以大幅提升代码的简洁性和可维护性。
类
- 根据类来创建对象称为实例化，这让我们能够使用类的实例，例如my_dog=Dog('xiaobai',6) my_dog为实例
- 类中的函数称为方法
- __init__()是一个特殊的方法，每当运行类时python都会自动调用它
- 类中以self.为前缀的变量可以供类中所有方法使用，例如self.name=name 目的是将name实参传递给name变量，像这样可以通过实例访问的变量称为属性，调用方式my_dog.name
创建和使用类
- 创建一个小狗类Dog----它表示的不是特定的小狗，而是任意小狗
- 对于大多数宠物狗它们都有名字和年龄，还会坐下和打滚，大多数小狗都具备这两项信息（名字和年龄）和两种行为（坐下和打滚），Dog类将包含他们
class Dog:
"""一次模拟小狗的简单尝试"""
def __init__(self,name,age,*args):
"""初始化属性 name和age"""
self.name = name
self.age = age
self.foods = args
def sit(self):
"""模拟小狗收到命令后坐下"""
print(f"{self.name} 现在立刻坐下!!!")
def roll_over(self):
"""模拟小狗收到命令后打滚"""
print(f"{self.name} 现在立刻打滚!!!")
my_dog = Dog('xiaobai',6,'香肠','牛肉')
print(f'我的小狗的名字：{my_dog.name}')
print(f'我的小小狗的年龄：{my_dog.age}')
print(f'{my_dog.name} 爱吃的食物有：{my_dog.foods}')
my_dog.sit()
my_dog.roll_over()
your_dog=Dog('tudou',3,)
print(f'你的小狗的名字：{your_dog.name}')
print(f'你的小小狗的年龄：{your_dog.age}')
your_dog.sit()
your_dog.roll_over()
修改属性值的方式
一个模拟汽车的类
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self,make,model,year):
"""初始化汽车属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_describe_name(self):
"""返回描述信息"""
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
"""打印出汽车的里程表英里数"""
print(f"该车的里程表: {self.odometer_reading}英里")
my_new_car = Car('china','小米','2025')
print(my_new_car.get_describe_name())
my_new_car.read_odometer()
1.直接通过实例修改属性值
my_new_car.odometer_reading = 20
my_new_car.read_odometer()
2.通过方法修改属性的值
def update_odometer(self,mileage):
"""将里程表设置成指定的值"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("不能回调英里数")
my_new_car.update_odometer(50)
my_new_car.read_odometer()
3.通过方法让属性的值传递
def increment_odometer(self,miles):
"""让里程表读书增加指定的量"""
if miles >=0:
self.odometer_reading += miles
else:
print("增加里程表英里数不能为负数")
my_new_car = Car('china','小米','2024')
print(my_new_car.get_describe_name())
my_new_car.update_odometer(50)
my_new_car.read_odometer()
my_new_car.increment_odometer(20)
my_new_car.read_odometer()
继承
- 当编写类时，并非总是从头开始，如果要编写的类是一个既有的类的特殊属性，可以使用继承
- 当一个类继承另一个类时，将自动获取后者的所有属性和方法，原有的类称为父类，而新的类称为子类
- 子类不仅继承了父类的所有属性和方法，也还可以定义自己的属性和方法
- 创建子类时，父类必须包含在该文件中且必须在子类的前面
- 定义子类时，必须在括号内指定父类名称
- super()是一个特殊的函数，让你能够调用父类的方法，这行代码让python调用Car类的__init__()方法，从而让ElectricCar实例包含这个方法定义的所有属性。父类也成为超类(superclass)，函数名super由此得名
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self,make,model,year):
"""初始化汽车属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_describe_name(self):
"""返回描述信息"""
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def update_odometer(self,mileage):
"""将里程表设置成指定的值"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("不能回调英里数")
def read_odometer(self):
"""打印出汽车的里程表英里数"""
print(f"该车的里程表: {self.odometer_reading}英里")
def increment_odometer(self,miles):
"""让里程表读数增加指定的量"""
if miles >=0:
self.odometer_reading += miles
else:
print("增加里程表英里数不能为负数")
class ElectricCar(Car):
"""电动汽车的独特之处"""
def __init__(self, make, model, year):
super().__init__(make, model, year)
my_leaf = ElectricCar('china','爱玛','2012')
print(my_leaf.get_describe_name())
重写
重写父类中的方法
- 如果父类中的一些方法不能满足子类的需求，就可以用下面的方法重写：
- 在子类中定义一个与重写的父类方法同名的方法。
- 这样python将忽略这个父类的方法，你只需关注子类中定义的相应方法
#!/usr/bin/python3
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
-->输出：
调用子类方法
调用父类方法
重构
很多时候虽然代码能够正确地运行，但还可以将其划分为一系列完成具体工作的函数来进行改进。这样的过程称为重构。重构让代码更清晰、更易于理解、更容易扩展。
接下来重构以下代码:
#!/usr/bin/python3
#_*_coding:utf-8_*_
from pathlib import Path
import json
path = Path('username.json')
if path.exists():
contents = path.read_text()
username = json.loads(contents)
print(f"您好 {username}")
else:
username = input("输入你的名字: ")
contents = json.dumps(username)
path.write_text(contents)
print(f"您好 {username}")
重构后：
#!/usr/bin/python3
#_*_coding:utf-8_*_
from pathlib import Path
import json
def greet_user():
"""问候其名字"""
path = Path('username.json')
if path.exists():
contents = path.read_text()
username = json.loads(contents)
print(f"您好 {username}")
else:
username = input("输入你的名字: ")
contents = json.dumps(username)
path.write_text(contents)
print(f"您好 {username}")
greet_user()
接下来再次重构greet_user()函数，不让他执行那么多的功能：
#!/usr/bin/python3
#_*_coding:utf-8_*_
from pathlib import Path
import json
def get_stored_username(path):
"""如果存储了用户名则使用它"""
if path.exists():
contents = path.read_text()
username = json.loads(contents)
return username
else:
return None
def greet_user():
"""问候其名字"""
path = Path('username.json')
username = get_stored_username(path)
if username:
print(f"您好 {username}")
else:
username = input("输入你的名字: ")
contents = json.dumps(username)
path.write_text(contents)
print(f"您好 {username}")
greet_user()
还可以在细分greet_user()函数功能：
#!/usr/bin/python3
#_*_coding:utf-8_*_
from pathlib import Path
import json
def get_stored_username(path):
"""如果存储了用户名则使用它"""
if path.exists():
contents = path.read_text()
username = json.loads(contents)
return username
else:
return None
def get_new_username(path):
"""提示输入用户名"""
username = input("输入你的名字: ")
contents = json.dumps(username)
path.write_text(contents)
return username
def greet_user():
"""问候其名字"""
path = Path('username.json')
username = get_stored_username(path)
if username:
print(f"您好 {username}")
else:
username = get_new_username(path)
print(f"您好 {username}")
greet_user()
类的私有属性
- _ _private_attrs，python中以两个下划线开头声明该属性为私有，不能被类的外部调用或直接访问
#!/usr/bin/python3
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 报错，实例不能访问私有变量
-->输出：
1
2
2
Traceback (most recent call last):
File "test.py", line 16, in <module>
print (counter.__secretCount) # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通