locals是python的内置函数，他可以以字典的方式去访问局部和全局变量
vars()本函数是实现返回对象object的属性和属性值的字典对象
eval()将字符串str当成有效的表达式来求值并返回计算结果
go
#!/usr/bin/python3
#-*- coding = uft-8 -*-
guo = 666
str1 = "guo"
str2 = "__doc__"
class c:
a = 100
print("第一种方法：", locals()[str1])
#flag = locals()[str2]
print("第二种方法：", vars()[str1])
print("第三种方法：", eval(str1))字符串→变量名
eval 执行表达式
exec 执行语句
字符串←变量名
globals 全局变量
locals 局部变量
vars 类的成员
go
i = 0
exec('j = 0')
print(globals())
go
class Dummy(object):
def __init__(self) -> None:
self.i = 0
exec('self.j = 0')
dummy = Dummy()
print(vars(dummy))
go
class EasyArgs(object):
def __init__(self, **kvps):
self.add(**kvps)
def add(self, **kvps): # 函数参数名转化成字符串(字典的键)
for k,v in kvps.items():
exec(f'self.{k} = None') # 字符串转化成示例的成员变量名
vars(self)[k] = v
if __name__ == '__main__':
args = EasyArgs(batch_size = 32)
args.add(epochs = 64)
print(vars(args)) # 成员变量名转化成字符串
print(args.batch_size) # 直接根据成员变量名使用变量
print(args.epochs)
go
#exec 会把字符串两边的引号去掉
info_dict = {'create_time':'ct','user_id':'uid', 'cookie_id':'ci', 'product_name':'pn', 'product_version':'pv', 'device':'di'}
for i in info_dict.items():
exec(i[0] + "='%s'" % i[1])
print create_time #这里在打印时create_time必须全部写，不会提示。编号函数描述
| 序号 | 函数 | 注释 |
|---|---|---|
| 1 | int(x [,base]) | 将x转换为整数。如果x是字符串，则要base指定基数。 |
| 2 | float(x) | 将x转换为浮点数。 |
| 3 | complex(real [,imag]) | 创建一个复数。 |
| 4 | str(x) | 将对象x转换为字符串表示形式。 |
| 5 | repr(x) | 将对象x转换为表达式字符串。 |
| 6 | eval(str) | 评估求值一个字符串并返回一个对象。 |
| 7 | tuple(s) | 将s转换为元组。 |
| 8 | list(s) | 将s转换为列表。 |
| 9 | set(s) | 将s转换为集合。 |
| 10 | dict(d) | 创建一个字典，d必须是(key，value)元组的序列 |
| 11 | frozenset(s) | 将s转换为冻结集 |
| 12 | chr(x) | 将整数x转换为字符 |
| 13 | unichr(x) | 将整数x转换为Unicode字符。 |
| 14 | ord(x) | 将单个字符x转换为其整数值。 |
| 15 | hex(x) | 将整数x转换为十六进制字符串。 |
| 16 | oct(x) | 将整数x转换为八进制字符串 |
删除开头空白lstrip()、删除末尾空白rstrip()、删除两端空白strip()
go
a='pp '
a.rstrip()
print(a)
#字符串中添加制表符可以使用字符组合\t
print("\tppp")
字符串中添加换行，可以使用换行符\n
print("\tppp\n")
同时包含制表符和换行符，字符串 \n\t
print("\tppp\n")
name = "Ada Lovelace"
print(name.upper())
print(name.lower())Python-python强制转换成字符串
go
a = 123
b = str(a)
print(b, type(b)) # '123', <class 'str'>
a = 123
b = repr(a)
print(b, type(b)) # '123', <class 'str'>
a = '中文'
b = unicode(a, 'utf-8')
print(b, type(b)) # u'\u4e2d\u6587', <class 'unicode'>
go
def namestr(obj, namespace):
return [name for name in namespace if namespace[name] is obj]
print(namestr(lr_origin,globals()),'\n',
namestr(lr_origin,globals())[0])
import inspect, re
def varname(p):
for line in inspect.getframeinfo(inspect.currentframe().f_back)[3]:
m = re.search(r'\bvarname\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)', line)
if m:
return m.group(1)
varname(lr_origin)Python如何创建字典
go
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict)
#访问字典的值
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict['语文']) # 通过键"语文"获取对应的值
#添加键值对
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
scores_dict['物理'] = 97 # 添加 '物理': 97
print(scores_dict) # {'语文': 105, '数学': 140, '英语': 120, '物理': 97}
#删除键值对
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
del scores_dict['数学'] # 删除 '语文'： 105
print(scores_dict) # 输出 {'语文': 105, '英语': 120}
#修改字典值
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
scores_dict['数学'] = 120 # 修改将"数学"修改为120
print(scores_dict) # 输出 {'语文': 105, '数学': 120, '英语': 120}
判断键值对是否存在
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
# 判断scores_dict是否包含名为'语文'的key
print('语文' in scores_dict) # True
# 判断scores_dict不包含'历史'的key
print('历史' not in scores_dict) # True
#clear()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict) # 输出 {'语文': 105, '数学': 140, '英语': 120}
scores_dict.clear() # 删除字典所有内容
print(scores_dict) # 输出{}
#get()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.get('历史')) # 输出 None
print(scores_dict['历史']) # 报错 KeyError: '历史'
#update()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
scores_dict.update({'语文': 120, '数学': 110})
print(scores_dict) # 输出{'语文': 120, '数学': 110, '英语': 120}
#items()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.items()) # 输出 dict_items([('语文', 105), ('数学', 140), ('英语', 120)])
#keys()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.keys()) # 输出 dict_keys(['语文', '数学', '英语'])
#values()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.values()) # 输出 dict_values([105, 140, 120])
#pop()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
scores_dict.pop('英语') # 删除'英语'的键和值
print(scores_dict) # 输出{'语文': 105, '数学': 140}
#popitem()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.popitem()) # 输出('英语', 120)
#setdefault()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
# 设置'语文'默认值为100
scores_dict.setdefault('语文', 100)
print(scores_dict) # 输出{'语文': 105, '数学': 140, '英语': 120}
# 设置'历史'默认值为140
scores_dict.setdefault('历史', 140)
print(scores_dict) # 输出{'语文': 105, '数学': 140, '英语': 120, '历史': 140}
#fromkeys()方法
scores_dict = dict.fromkeys(['语文', '数学'])
print(scores_dict) # 输出{'语文': None, '数学': None}
scores_dict = dict.fromkeys(('语文', '数学'))
print(scores_dict) # 输出{'语文': None, '数学': None}
# 使用元组创建包含2个key的字典，指定默认的value
scores_dict = dict.fromkeys(('语文', '数学'), 100)
print(scores_dict) # 输出{'语文': 100, '数学': 100}
#len()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(len(scores_dict)) # 输出 3
#str()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(str(scores_dict)) # 输出{'语文': 105, '数学': 140, '英语': 120}
#type()方法
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(type(scores_dict)) # 输出<class 'dict'>
#Python字典的for循环遍历
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
for key in scores_dict:
print(key)
#遍历value的值
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
for value in scores_dict.values():
print(value)
#遍历字典键值对
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
for key in scores_dict:
print(key + ":" + str(scores_dict[key])) # 返回字符串
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
for i in scores_dict.items():
print(i) # 返回元组
scores_dict = {'语文': 105, '数学': 140, '英语': 120}
for key, value in scores_dict.items():
print(key + ':' + str(value))
#将两个列表组成一个字典
list_a = ['zhangsan', 'lisi', 'wangwu']
list_b = ['14', '42', '23']
dicts = dict(zip(list_a, list_b))
print(type(dicts))
print(dicts)
# 输出结果
>>> <class 'dict'>
{'zhangsan': '14', 'lisi': '42', 'wangwu': '23'}
#将元组转换为列表
# 定义元组
GFG_tuple = (1, 2, 3)
# 将元组转换为列表
GFG_list = list(GFG_tuple)
print(GFG_list)
#使用 map() 函数将元组转换为列表
# 定义元组
GFG_tuple = (1, 2, 3)
# 使用 map 函数将元组转换为列表
GFG_list = list(map(lambda x: x, GFG_tuple))
print(GFG_list)
#把列表转成元组 使用tuple
list_a = [1, 2, 3, 4, 5, 6]
list_b = tuple(list_a)
print(list_b)
#列表的基本操作
#修改元素: 列表名【索引】= 新值
#增加元素 append（）方法
#insert()方法
guests = ['张三','李四','王五','小阿丁']
guests.insert(0,'小红')
#注意：列表每次增加的元素可以是任何类型的
#删除元素:del命令
del guests[0]
#pop（）方法默认删除最后一个元素
guests=['张三', '李四', '王五', '小阿丁']
guests.pop(1)
#remove（）方法
guests.remove('李四')
'''
len() #统计和返回指定列表的长度
in() not in() #判断指定元素是否在列表中
index() #在列表中那个查找指定的元素，若存在则返回指定元素在列表中的索引，若存在多个则返回最小的，若不存在会报错
count() #统计并返回列表中指定元素的个数
sort() #列表元素从小到大升序排序，改变了源列表的元素的顺序
sorted() #列表元素从小到大升序排序，生成排序后的副本，不改变原列表的顺序
nums.sort()
nums.sort(reverse = True)
'''
#列表的扩充 "+"运算可以将两个列表"加"起来，生成一个新的列表，但是原来的列表并没有发生变化。
# extend（）方法不同于"+"方法，因为"+"必须通过赋值语句才能将结果写入新的列表中，而extend()方法可以直接将新的列表添加至原列表之后
#列表的乘法运算是指将列表中的元素重复多遍
#copy（） 方法
#列表的切片实现复制
list3 = list1[1:3]
#del 列表名
#字符串与列表之间的转换
name = '小阿丁,小红'
list1 = list(name)
#split()方法是处理字符串的方法，用来根据指定的分隔符拆分字符串，并生成列表
sentence = 'I want to be split by spcaes.'
name = '小阿丁,小红'
sentencelist = sentence.split()
sentencelist
['I', 'want', 'to', 'be', 'split', 'by', 'spcaes.']
namelist = name.split(',')
namelist
['小阿丁', '小红']
# 定义一个字符串列表
str_list = ['Hello', 'World', 'Python', 'is', 'awesome']
# 使用空字符串作为连接符，将列表转换为字符串
result = ''.join(str_list)
# 定义一个字符串列表
str_list = ['Moonshot', 'AI', 'Assistant']
# 初始化一个空字符串
result = ''
# 循环遍历列表，将每个元素添加到字符串中
for item in str_list:
result += item
# 输出结果
print(result) # 输出: MoonshotAIAssistant
#字符串的索引与切片
#字符串的处理与操作
'''
len(x) #返回字符串x的长度
str(x) #将任意类型的x转化为字符串类型
chr(x) #返回Unicode编码为x的字符
ord(x) #返回字符x的Unicode编码
hex(x) #将整数x转化为十六进制数
oct(x) #将整数x转化为八进制数
find() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则返回-1
rfind() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则返回-1
index() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则抛出异常
rindex() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则抛出异常
count() #用来返回一个字符串在另一个字符串中出现的次数，若不存在则返回0
split() #以指定字符为分隔符，从原字符串的左端开始将其分割为多个字符串，并返回包含分割结果的列表
rsplit() #以指定字符为分隔符，从原字符串的右端开始将其分割为多个字符串，并返回包含分割结果的列表
partition() #以指定字符串为分隔符将原字符串分割为3个部分，分隔符之前的字符串，分隔符字符串和分隔符之后的字符串
rpartition() #以指定字符串为分隔符将原字符串分割为3个部分，分隔符之前的字符串，分隔符字符串和分隔符之后的字符串
join() #将列表中多个字符串进行连接，并在相邻两个字符串之间插入指定字符，返回新字符串
lower() #将字符串转换为小写字符串
uppper() #将字符串转换为大写字符串
capitalize() #将字符串首字母变为大写
title() #将字符串中每个单词的首字母都变为大写
swapcase() #将字符串中的字符大小写互换
replace() #替换字符串中指定字符或子字符串
strip() #删除字符串两端空白字符
rstrip() #删除字符串右端空白字符
lstrip() #删除字符串左端空白字符
startswith() #判断字符串是否以指定字符开始
endswith() #判断字符串是否以指定字符结束
isupper() #是否全为大写
islower() #是否全为小写
isdigit() #是否全为数字
isalnum() #是否全为字母或汉字或数字
isalpha() #是否全为字母或汉字
center() #字符串居中对齐
ljust() #字符串居左对齐
rjust() #字符串居右对齐
zfill() #输出指定宽度，不足的左边填0
format()格式化方法
当使用format()方法格式化字符串的时候，首先需要在"{}"中输入"："，然后在":"之后分别设置<填充字符><对齐方式><宽度>
"{:*^20}".format("milke")
#split() 和 join() 方法示例
my_string = "apple, banana, cherry"
splitted_str = my_string.split(", ")
print(splitted_str) # 输出：['apple', 'banana', 'cherry']
fruits = ['apple', 'banana', 'cherry']
joined_str = ", ".join(fruits)
print(joined_str) # 输出：apple, banana, cherry
#find() 方法示例
my_string = "Hello, World!"
index = my_string.find("World")
if index != -1:
print(f"Substring found at index: {index}")
else:
print("Substring not found")
#replace() 方法示例
my_string = "Hello, World!"
new_string = my_string.replace("World", "Python")
print(new_string) # 输出：Hello, Python!
#count() 方法用于计算字符串中指定子字符串出现的次数
my_string = "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
count = my_string.count("wood")
print(f"The word 'wood' appears {count} times in the string.")
#isalpha() 方法用于检查字符串是否只包含字母字符
alpha_str = "Hello"
if alpha_str.isalpha():
print("The string contains only alphabetic characters.")
else:
print("The string contains non-alphabetic characters.")
#isdigit() 方法用于检查字符串是否只包含数字字符
digit_str = "12345"
if digit_str.isdigit():
print("The string contains only digits.")
else:
print("The string contains non-digit characters.")
#isalnum() 方法用于检查字符串是否只包含字母和数字字符的组合
alnum_str = "Hello123"
if alnum_str.isalnum():
print("The string contains only alphanumeric characters.")
else:
print("The string contains non-alphanumeric characters.")
# 多行字符串示例
multiline_string = """Hello,
World!"""
print(multiline_string)
# 字符编码转换示例
my_string = "你好"
encoded_string = my_string.encode("utf-8")
decoded_string = encoded_string.decode("utf-8")
print(encoded_string)
print(decoded_string)
# 文本处理示例
text = "Hello, this is a sample text. #example"
cleaned_text = text.replace("#example", "").strip()
print(cleaned_text)
# 字符串拼接优化示例
items = ['apple', 'banana', 'cherry']
joined_string = ''.join(items)
print(joined_string)
def reverse_string(input_str):
reversed_str = ''
for char in input_str:
reversed_str = char + reversed_str
return reversed_str
# 测试函数
input_string = "Hello, World!"
reversed_string = reverse_string(input_string)
print(reversed_string) # 输出结果为：!dlroW ,olleH
'''