标签：selected for mode 返回字典 world 内存 inpu replace dem
输入：input （输入的数据类型是str型）
输出：print （输出多个值时中间用逗号隔开，sep可以指定多个值之间的连接符）
eg:print（age，7000，sep‘+’）
500+7000
定义：python中的变量是在第一次赋值的时候就已经定义了
（1）int 整型。通常被称为是整型或整数，是正或负整数，不带小数点
（2）float 浮点。由整数部分与小数部分组成
（3）complex：复数。由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
eg:定义：num = 4+3j 4为实部 3为虚部
（4）运算：
加法：3+4
减法：4-3
乘法：3*4
除法：4/3
取整：3 // 2
取余：6 % 4
次方：2**3（2的3次方）
（1）.字符串的拼接：
var = ‘hello‘
var1 = “world!”
var 3= ‘1‘
var4 = var + var1
print(var4)
print(var,var1)
print(var+‘, ‘+var1)
（2）.下标索引：字符串的索引分为正数和负数
正数下标从左往右，从0开始，最后一个下标是len（a）-1；
负数下标从右往左，从-1开始，最后一个下标是-len（a）
（3）截取：
正数下标a[3:5] 截取的是下标为3的元素到下标为4的元素，冒号右边下标对应的元素不会截取到；
负数下标a[-4:-1] 截取的是下标为-1的元素倒下标为-4的元素，冒号右边下标对应的元素不会截取到；
索引截取：var = ‘hello world！‘
print(var)
print(var[2::2])
结果为：lowrd
从下标为2的元素开始，隔两个取一个元素
var = ‘hello world！‘
print(var)
print(var[::-1])
结果为：dlrow olleh
从下标为-1的元素开始向左倒取
var = ‘hello world！‘
print(var)
print(var[3::-2])
结果为：le
从下标为3的元素开始，按负数下标原则，向左倒取，隔两个取一个元素
?
（4）.字符串的函数：
1.len：返回字符串的长度
eg:a = ‘hello world‘
print(len(a))
结果为：11
2.count:查看出现的次数
eg:a = ‘hello world‘
a.count（‘l‘）
结果为：3
表示‘l’在a字符串中出现了三次
3.capitalize:将字符串的第一个字符转换为大写
eg:a = ‘hello world‘
a.capitalize（）
结果为：Hello world
4.center：返回一个固定宽度且居中的字符串，剩余内容由指定的字符填充，若不指定填充字符，默认空格填充
eg:a = ‘hello world‘
a.center(20,‘*‘)
结果为：*****hello world*****
5.find:检测输入内容是否在字符串中
eg：a = ‘hello world‘
a.find(‘o‘)
结果为：4
显示的是查找字符的下标，默认显示第一次出现的下标
eg：a = ‘hello world‘
a.find(‘o‘,3,5)
结果为：4
显示查找字符的下标，后面可添加范围，范围用下标表示
6.replace：将字符串中的某些内容进行替换
eg:a = ‘hello world‘
a.replace(‘o‘,‘#‘)
结果为：hell# w#rld
默认全部替换
eg:a = ‘hello world‘
a.replace(‘o‘,‘#‘，1)
结果为：hell# world
添加替换次数，则从头开始按次数替换
7.split：以输入内容为分隔符截取字符串
eg:a = ‘hello world‘
a.split(‘o‘，1)
结果为：hell world
以‘o’为分割符把该字符串分割成两个，作为分隔符的字符会取消输出，后面数字代表分割几次（建议分隔符使用不需要的内容来作为）
8.index:跟find方法相同，只不过若输入内容不在字符串中会报错
eg:a = ‘hello world‘
a.index(‘e‘,0,3)
结果为：1
显示下标，若输入内容在字符串中没有，则会报错,可以根据下标指定范围（出现错误后面的代码则不执行，若想之后的代码继续执行，建议使用 find）
9.isalnum：如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回 False
eg:a = ‘hello world‘
a.isalnum()
结果为：true
eg:a = ‘hello world%‘
a.isalnum()
结果为：false
10.isalpha：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回False
eg:a = ‘helloworld‘
a.isalpha()
结果为：true
11.isdigit:字符串只包含数字则返回True否则返回False
eg:a = ‘hello world‘
a.isdigit()
结果为：false
12.islower:如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True,否则返回False
eg:a = ‘hello world‘
a.islower()
结果为：true
13.isspace:如果字符串中只包含空格，则返回True，否则返回False
eg:a = ‘hello world‘
a.islower()
结果为：false
14.istitle:检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
eg:a = ‘hello world‘
a.istitle()
结果为：false
15.lower:转换字符串中所有大写字符为小写
eg:a = ‘Hello world‘
a.istitle()
结果为：hello world
16.max:返回字符串 str 中最大的字母。
eg:a = ‘hello world‘
max(a)
结果为：w
17.min:返回字符串 str 中最小的字母
eg:a = ‘hello world‘
min(a)
结果为：‘ ‘(空格)
以ASCII码表为基准
18.startswith:检查字符串是否是以 obj 开头，是则返回True，否则返回False
eg:a = ‘hello world‘
a.startswth(‘h‘)
结果为：true
eg:a = ‘hello world‘
a.startswith(‘hel‘)
结果为：true
列表的定义：
方式一：list1 = [] 常用
方式二：list2 = list（）
下标索引：
与字符串规则一致
正数下标从左往右，从0开始，最后一个下标是长度减一
负数下标从右往左，从-1开始，最后一个下标是负长度
列表截取：
names = [‘tom‘,‘LISI‘,56,78,89]
#取下标对应的元素
#print(names[-1])
?
#截取一段：
#print(names[1:5])
?
#截取下标为2的元素后面的所有内容
#print(names[2:])
#print(names[-4:])
列表嵌套：输出列表里嵌套的列表的某个值
names = [‘tom‘,‘LISI‘,56,‘哈哈‘,2,‘safe‘,[‘1‘,2,4],78,89]
print(names[6][1])
列表方法：
1、.append：在列表末尾添加新的对象
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
names.append(‘d‘)
print(names)
结果为：[‘a‘,b‘,‘c‘,‘d‘]
2、.count：统计某个元素在列表中出现的次数
eg:names = [‘a‘,‘b‘,‘c‘,‘c‘]
print(names)
a = names.count(‘c‘)
print(a)
结果为：2
3、.extend：在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
list1 = [24,25,26]
names.extend(list1)
print(names)
结果为：[‘a‘,b‘,‘c‘,24,25,26]
4、.index：从列表中找出某个值第一个匹配项的索引位置，索引从0开始
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
names.index(‘c‘)
print(names)
结果为：2
输入元素值，结果显示的是下标
5、.insert：将对象插入列表
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
names.insert(1,5)
print(names)
结果为：[‘a‘,‘b‘,5,‘c‘]
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
list1 = [‘ds‘]
names.insert(1,list1)
print(names)
结果为[‘a‘,‘b‘,[‘ds‘],‘c‘]
6、.pop(index) ：移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
eg:names = [‘a‘,‘b‘,‘c‘]
print(names)
names.pop(1)
print(names)
结果为：[‘a‘,‘c‘]
移除时输入元素的下标
7、.remove(obj)： 移除列表中某个值的第一个匹配项
eg:names = [‘a‘,‘b‘,‘c‘，‘a‘,‘d‘,‘a‘]
print(names)
names.remove(‘a‘)
print(names)
结果为：[‘b‘,‘c‘，‘a‘,‘d‘,‘a‘]
8、.reverse()：反向列表中元素，倒转
eg:names = [‘a‘,‘b‘,‘c‘，‘a‘,‘d‘,‘a‘]
print(names)
names.reverse()
print(names)
结果为：[‘a‘,‘d‘,‘a‘，‘c‘,‘b‘,‘a‘]
9、.sort([func])： 对原列表进行排序
eg:names = [24,15,36，26,31,29]
print(names)
names.sort()
print(names)
结果为：[15,24,26,29,31,36]
定义元组：
如果只有一个元素，必须在元素后加‘,‘；
元组里可以存放任意类型的数据；
一旦定义，不可更改；
不可添加，不可分割
方式一：tup1 = （‘dfs’，）
方式二：tup2 = tuple（）
元组索引与列表、字符串规则一致。
截取：tup1 = ("sadfsa",["sda","sds",45],(34,45))
print(type(tup1))
输出类型为:tuple
print(tup1[1])
截取元组中下标为1的元素是一个列表，显示为：[‘sda‘,‘sds‘,45]
print(tup1[1][-1])
截取元组中下标为1的元素是一个列表中的下标为-1的元素，显示为：45
print(tup1[1:])
截取元组中下标为1的元素及后面所有的元素，显示为：（["sda","sds",45],(34,45)
?
元组常用函数：
1.len(tuple)：计算元组元素个数
eg:tup1 = （‘a‘,‘b‘,‘c‘）
print(len(tup1))
2.max(tuple)：返回元组中元素最大值
eg:tup1 = （‘a‘,‘b‘,‘c‘）
print(max(tup1))
3.min(tuple)：返回元组中元素最小值
eg:tup1 = （‘a‘,‘b‘,‘c‘）
print(min(tup1))
4.tuple(seq)：将列表转换为元组
eg:list1 = [1,2,3]
a = tuple(list1)
print(a)
定义：
方式一：set1 = set（）定义空集合
方式二：set2 = {123}
特点：无序不重复元素，去重，没有下标索引，支持集合运算
?
类型转换：list1 = [1,2,3]
set1 = set(list1)
print(set1)
列表转集合
?
集合运算：
a = t | s # t 和 s的并集
b = t & s # t 和 s的交集
c = t – s # 求差集（项在t中，但不在s中）
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
?
常用操作：
1.添加一个元素 s.add()
eg:s1 = {1,2,3}
s1.add(4)
print(s1)
2.删除一个元素 s.remove()
eg:s1 = {1,2,3}
s1.remove(2)
print(s1)
3.删除整个集合 del (s)
eg:s1 = {1,2,3}
del（s1）
print(s1)
4.长度计算 len(s)
eg:s1 = {1,2,3}
len（s1）
print(s1)
定义：
方式一：t1 = {} 定义空字典
方式二：t1 = dict（）
t1= {键：值，键：值}
t1= {key1：value1,key2:value2}
?
特点：
以键值对的形式存放，键要唯一；
不是通过索引存取；
值可以是任意数据类型
常用操作：
1. print(dict[‘thrid‘]) 后台打印键为thrid的值
2. dict[‘thrid‘] = ‘网易‘ 将键为thrid的值修改成‘网易‘
3. del dict[‘second‘] 删除键为second的键值对
4. dict.clear() 清空字典
5. del dict 删除字典
字典函数：
1.clear() 删除字典内所有元素
?
2.copy() 复制
eg:t1 = {}
t2 = t1.copy
print（t2）
3.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
eg:t1 = {}
t2 = t1.fromkeys（‘zaq‘,‘s‘）
print（t2）
结果为：{‘z‘：‘s‘，‘a‘：‘s‘，‘q‘：‘s‘}
4.get() 返回指定键的值，如果值不在字典中返回default值
eg:t1 = {a:b,c:d}
e = t1.get(a)
print（e）
5.keys() 以列表返回一个字典所有的键
eg:t1 = {a:b,c:d}
e = t1.keys()
print（e）
6.setdefault 和get()类似,但如果键已经不存在于字典中，将会添加键并将值设为default
eg:t1 = {a:b,c:d}
t1.setdefault(e)
print（t1）
如果键存在，不会对原有键和值进行修改
7.update(dict2) 把字典dict2的键值对更新到dict里
eg:t1 = {a:b,c:d}
t2 = {a1:b1,c1:d1}
t1.update(t2)
print（t1）
8.values() 以列表返回字典中的所有值
eg:t1 = {a:b,c:d}
a = t1.values()
print（t1）
分支结构（判断）：if elif else语句
循环结构：for循环可以遍历列表
1.for循环：for 变量 in 次数/列表
执行的语句
for循环可以遍历输出列表的元素，注意循环次数是由列表中的元素个数控制的
eg:
names = [‘hello‘,‘tom‘,‘hu‘]
for one in names:
print(one)
eg:
for one in range(1,10):
print(one)
输出1到九
for one in range(1,100，5):
print(one)
输出1到100，隔5个取一次
?
2.while循环：while 条件：
执行语句
3、break和continue：
break：终止整个循环
continue：终止本次循环
字符串格式化输入：
方式一：
print（"%s的年龄是%d" %(name,age)）
注意：%s代表字符串，%d代表整数，%f代表浮点数
方式二：format
print（{0}的年龄是{1}.format(name,age)）
注意：format在输入值的时候是根据位置传递的，可以在{}指定参数位置，下标传递
方式三：
print（f"{name}的年龄是{age}"）
定义：Python定义函数使用def关键字，函数名的命名规则和变量类似，要先定义再调用
函数名为自定义名称，参数列表为传入的参数
def 函数名 （参数列表）
函数体
直接输出函数名，会输出函数的内存地址
作用：函数用于将相关功能打包并参数化
1、必填参数：一旦定义，调用时必须传入值，多个参数定义的时候中间使用逗号隔开
2、默认参数：函数参数定义的时候指定默认值，在函数调用的时候可以不输入值，如果不传入则使用默认值，如果传入值，就是传入的新值
3、可变参数（不定长参数）：* 可以接收在调用时传入的多个值，存放在元组中
4、关键字可变数量参数：**
定义完成后传入的值要以键值对的形式传入，传入的值为一个字典
注意：上述四种参数参数位置不可改变
函数里面可以继续调用其他函数
?
函数的返回值：
递归函数：当一个函数在函数体内调用其本身时，这个函数就称为递归函数
模块：python中一个.py文件就是一个模块
能避免函数名、变量名重名，增加代码的可读性
导入模块：import 模块名 （导入内置模块）
方式一：import 模块名
模块名.函数名()
方式二：from 模块名 import 函数名
调用 （导入单个函数）
from 模块名 import 函数名，函数名
调用 （导入多个函数）
from 模块名 import *
调用 （导入全部函数）
方式三：import 包名.模块名 as 模块名
模块名.函数名（） （导入指定模块）
方式四：import 包名.模块名，包名.模块名
包名.模块名.函数名（）
方式五：form 包名.模块名 import 函数名，函数名
调用 （导入多个函数）
方式六：from 包名.模块名 import *
调用 （导入某个模块的所有函数）
包：python新建的包里都会有一个__inint__.py文件（初始化文件），一般是包里面存放着模块
访问这个网址： https://regex101.com/ 来验证正则表达式的正确性
元字符：metacharacters
它们出现在正则表达式字符串中，不是表示直接匹配他们， 而是表达一些特别的含义。
包含： . * + ? \ [ ] ^ $ { } | ( )
1、点-匹配所有字符，表示要匹配除了换行符之外的任何单个字符
比如，从下面的文本中选择出所有的颜色
苹果是绿色的
橙子是橙色的
香蕉是黄色的
乌鸦是黑色的
也就是要找到所有以 色 结尾，并且包扩前面的一个字符的词语。就可以这样写正则表达式 .色
其中 点 代表了任意的单个字符， .色 合起来就表示要找任意一个字符后面是 色 这个字，合起来两个字的字符串
eg：import re
p = re.compile(r‘.色‘)for one in p.findall(content):
print(one)
2、星号-重复匹配任意次，表示匹配前面的子表达式任意次，包括0次
比如，要选择每行逗号后面的字符串内容，包括逗号本身。
苹果，是绿色的
橙子，是橙色的
香蕉，是黄色的
乌鸦，是黑色的
猴子，
就可以这样写正则表达式 ，.* *紧跟在 . 后面， 表示任意字符可以出现任意次，所以整个表达式的意思就是在逗号后面的所有字符，包括逗号
eg：import re
p = re.compile(r‘，.*‘)for one in p.findall(content):
print(one)
注意： .* 在正则表达式中非常常见，表示匹配任意字符任意次数。当然这个 * 前面不是非得是 点 ，也可以是其它字符
4、加号-重复匹配多次，表示匹配前面的子表达式一次或多次，至少匹配一次，不包括0次
比如，要从文本中选择每行逗号后面的字符串内容，包括逗号本身。但是添加一个条件，如果逗号后面没有内容，就不要选择了。
苹果，是绿色的
橙子，是橙色的
香蕉，是黄色的
乌鸦，是黑色的
猴子，
就可以这样写正则表达式 ，.+
5、问号-匹配0-1次，匹配前面的子表达式0次或1次
比如，要从文本中，选择每行逗号后面的1个字符，也包括逗号本身
苹果，绿色的
橙子，橙色的
香蕉，黄色的
乌鸦，黑色的
猴子，
就可以这样写正则表达式 ，.?
6、花括号-匹配指定次数，表示前面的字符匹配指定的次数
比如 ，下面的文本
红彤彤，绿油油，黑乎乎乎乎，绿油油油油
?
表达式 油{3} 就表示匹配连续的 油 字3次
表达式 油{3,4} 就表示匹配连续的 油 字至少3次，至多4次
?
***贪婪模式和非贪婪模式
贪婪模式：在正则表达式中， ‘*’, ‘+’, ‘?’ 都是贪婪地，使用他们时，会尽可能多的匹配内容
非贪婪模式：也就是在后面加上 ?
7、对元字符的转义
反斜杠 \ 在正则表达式中有多种用途。比如，我们要在下面的文本中搜索所有点前面的字符串，也包含点本身
苹果.是绿色的
橙子.是橙色的
香蕉.是黄色的
如果，我们这样写正则表达式 .*. ， 肯定不对，因为 点 是一个元字符，直接出现在正则表达式中，表示匹配任意的单个字符，不能表示 . 这个字符本身的意思了，如果我们要搜索的内容本身就包含元字符，就可以使用 反斜杠进行转义，使用这样的表达式： .*\.
eg：import re
p = re.compile(r‘.*\.‘)for one in p.findall(content):
print(one)
反斜杠后面接一些字符，表示匹配 某种类型 的一个字符
\d 匹配0-9之间任意一个数字字符，等价于表达式 [0-9]
\D 匹配任意一个不是0-9之间的数字字符，等价于表达式 [^0-9]
\s 匹配任意一个空白字符，包括 空格、tab、换行符等，等价于表达式 [\t\n\r\f\v]
\S 匹配任意一个非空白字符，等价于表达式 [^ \t\n\r\f\v]
\w 匹配任意一个文字字符，包括大小写字母、数字、下划线，等价于表达式 [a-zA-Z0-9_]，缺省情况也包括Unicode文字字符，如果指定 ASCII 码标记，则只包括ASCII字母
\W 匹配任意一个非文字字符，等价于表达式 [^a-zA-Z0-9_]
反斜杠也可以用在方括号里面，比如 [\s,.] 表示匹配 ：任何空白字符，或者逗号，或者点
8、方括号-匹配几个字符之一，表示要匹配 指定的几个字符之一
[abc] 可以匹配 a, b, 或者 c 里面的任意一个字符。等价于 [a-c] 。
[a-c] 中间的 - 表示一个范围从a 到 c
如果在方括号中使用 ^ ， 表示 非 方括号里面的字符集合，[^\d] 表示，选择非数字的字符
9、起始、结尾位置 和 单行、多行模式
^ 表示匹配文本的 开头 位置。
正则表达式可以设定 单行模式 和 多行模式
如果是 单行模式 ，表示匹配 整个文本 的开头位置，如果是 多行模式 ，表示匹配 文本每行 的开头位置。
content = ‘‘‘001-苹果价格-60
002-橙子价格-70
003-香蕉价格-80‘‘‘
eg：import re
p = re.compile(r‘^\d+‘, re.M)for one in p.findall(content):
print(one)
注意：compile 的第二个参数 re.M ，指明了使用多行模式
$ 表示匹配文本的 结尾 位置。
如果是 单行模式 ，表示匹配 整个文本 的结尾位置，如果是 多行模式 ，表示匹配 文本每行 的结尾位置
比如，下面的文本中，每行最前面的数字表示水果的编号，最后的数字表示价格001-苹果价格-60，002-橙子价格-70,003-香蕉价格-80,如果我们要提取所有的水果编号，用这样的正则表达式 \d+$
10、竖线-匹配两者之一，表示 匹配 前者 或 后者，竖线在正则表达式的优先级是最低的， 这就意味着，竖线隔开的部分是一个整体
11、括号-组选择，括号称之为正则表达式的 组选择，是从正则表达式匹配的内容里面扣取出其中的某些部分
从下面的文本中，选择每行逗号前面的字符串，也 包括逗号本身
苹果，苹果是绿色的
橙子，橙子是橙色的
香蕉，香蕉是黄色的
就可以这样写正则表达式 ^.*， 。
但是，如果要求 不要包括逗号 呢，当然不能直接这样写 ^.* 因为最后的逗号是特征所在，如果去掉它，就没法找逗号前面的了，但是把逗号放在正则表达式中，又会包含逗号，所以使用组选择符 ： 括号，我们这样写 ^(.*)，
eg：import re
p = re.compile(r‘^(.*)，‘, re.MULTILINE)for one in p.findall(content):
print(one)
可以多次使用，我们要从下面的文本中，提取出每个人的 名字 和对应的 手机号
张三，手机号码15945678901
李四，手机号码13945677701
王二，手机号码13845666901
可以使用这样的正则表达式 ^(.+)，.+(\d{11})
eg：import re
p = re.compile(r‘^(.+)，.+(\d{11})‘, re.MULTILINE)for one in p.findall(content):
print(one)
标签：selected for mode 返回字典 world 内存 inpu replace dem
原文地址：https://www.cnblogs.com/blog-apply/p/13200410.html
