wordpress 获取子页面/南宁seo推广外包

locals是python的内置函数，他可以以字典的方式去访问局部和全局变量
vars()本函数是实现返回对象object的属性和属性值的字典对象
eval()将字符串str当成有效的表达式来求值并返回计算结果

#!/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 类的成员

i = 0
exec('j = 0')
print(globals())

class Dummy(object):def __init__(self) -> None:self.i = 0exec('self.j = 0')dummy = Dummy()
print(vars(dummy))

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] = vif __name__ == '__main__':args = EasyArgs(batch_size = 32)args.add(epochs = 64)print(vars(args))                # 成员变量名转化成字符串print(args.batch_size)           # 直接根据成员变量名使用变量print(args.epochs)

#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()

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强制转换成字符串

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'>

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如何创建字典

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_strreturn reversed_str# 测试函数
input_string = "Hello, World!"
reversed_string = reverse_string(input_string)
print(reversed_string)  # 输出结果为：!dlroW ,olleH
'''