一、列表

按索引取值

name=["张三","李四","果冻"]
name2=[1,3,2,11,4,8]

# 1.取值和取索引
# print(name[0])  #取值张三，从0开始，如果取值范围超过列表范围会报错

#索引，表示知道数据的内容，查找数据所在的位置
# print(name.index("果冻"))  #如果数据不在列表中，会报错

# 2.修改
# name[1] = "王二"      #超出范围会报错
# print(name)

# 3.增加
# name.append("辜友银") #append 在最后增加元素
# print(name)
# name.insert(1,"奥丁")  #insert 在列表1前面插入数据

# name1=["雷神","宇宙女","绿巨人","奥丁"]
# name.extend(name1)       # exted 添加元素组

# 4.删除
# name.remove("果冻")     # 删除前面第一次出现的数据“果冻”,remove删除指定数据
# #
# name.pop()              # pop,默认情况删除最后一个数据
# name.pop(0)             #指定删除对应列数据
# name.clear()            #清空列表

# 5.del删除，delete简称
# del name[3]              #本质上用来将一个变量从内存中删除
                            #在平时开发中，要用列表删除数据，不要用del删除，
                            #因为del从内存删除后，后续代码将不能在用这个数据


# 6.len,列表中总共包含元素的个数   len函数length 长度 的缩写
# len=len(name)
# print("列表中包含 %d 个元素"%len)

# 7.count 函数方法，统计某元素在列表中出现的次数
# count = name.count("张三")        # count次数
# print("张三在name列表中出现了 %d 次"%count)

# 8.排序 sort()升序，sort(reverse=Ture)降序，reverse()反转，逆序排列
# name2.sort()            # 升序
# print(name2)
# name2.sort(reverse=True)  #降序排列
# name2.reverse()              #逆序
# print(name2)

# 9.查找，in,not in
# a="奥丁" in(name)  # 奥丁是在name中    判断字典时，in只判断字典的key，而不判断值
b="奥丁" not in(name) # 奥丁不是在name中
# print(a)
print(b)
#
# print(name2)
# print(name)

二、字典

按键取值，无序

xiaoming = {"name":"小明",
            "sge":18,
            "gender":True,
            "hegiht":1.75,
            "weight":75.5}

1.取值
print(xiaoming["name"])  # 数据不存在报错
2.增加/修改
xiaoming["sex"] ="男"   # 如果key不存在，就是增加键值对
xiaoming["name"] = "小王"  # 如果key存在，就是修改键值对

3.删除
xiaoming.pop("name")
xiaoming.clear()    # 清空
name.remove("果冻")     # 删除前面第一次出现的数据“果冻”,remove删除指定数据

name.pop()              # pop,默认情况删除最后一个数据
name.pop(0)             #指定删除对应列数据
name.clear()            #清空列表

4.del删除，delete简称
del name[3]

5.统计键值对的数量  len
print(len(xiaoming))

6.合并键值对  update
xiaowang = {"hegihtwang":1.65}
print(xiaoming.update(xiaowang))

7.清空 clear
xiaoming.clear()

print(xiaoming)

三、元组

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

四、切片

num = "0123456789"
# 列表元组也可以切片，字典不可以切片
# num[开始位置:结束位置:步长],开始位置=0可以省略，结束位置=末尾可以省略，步长=1可以省略，

# 1.切取2-5的字符串
num1=num[2:6:1]
print(num1)

# 2.切取2-末尾的字符串
num2=num[2:]
print(num2)

# 3.截取从开始-5位置的字符串
num3=num[:6]
print(num3)

# 4.截取完整的字符串
num4=num[:]
print(num)

# 5.从开始位置，每隔一个字符截取字符串（使用步长）
num5=num[::2]
print(num5)

# 6.从索引1开始，每隔一个截取一个
num6=num[1::2]
print(num6)

# 7.截取从2至（末尾-1）的字符串
num[-1]     #-1表示倒数第一的一个数
num7=num[2:-1]
print(num7)

# 8.截取字符串末尾的两个数
num8=num[-2:]
print(num8)

# 9.字符串的逆序（面试）从右向左截取
num9=num[::-1]  # 表示从最后一个数开始，每截取一个数向左移动一位
print(num9)

五、元组和列表相互转换

# 列表可以修改（安全系数低），元组别人不可以修改（安全系数高）
# zu=(),    biao=[],    括号不同

# list(元组)，元组转化列表
# tuple(列表)，列表转化元组

# 1.修改前：list列表类型
biao=[1,2,3,4]
print(type(biao))
    # 修改后：tuple元组类型
biao1=tuple(biao)
print(type(biao1))

# 2.修改前：tuple元组类型
zu=(1,2,3,4)
print(type(zu))

# 3.修改后：list列表类型
zu1=list(zu)
print(type(zu1))

六、字符串对齐方式

1.居中 center

poem = ["你是猪",
        "辜友银",
        "你是个笨猪",
        "你是个大笨猪",
        "你是个超级大笨猪"]
        
 for poem_str in poem:
    print("|%s|" % poem_str.center(20," "))   # 居中对齐，其余地方用空格补全
    # 结果：
|        你是猪         |
|        辜友银         |
|       你是个笨猪        |
|       你是个大笨猪       |
|      你是个超级大笨猪      |
    

2.左对齐 ljust

for poem_str in poem:
    print("|%s|" % poem_str.ljust(20, "0"))   # 左对齐，其余地方0补全
# 结果
|你是猪00000000000000000|
|辜友银00000000000000000|
|你是个笨猪000000000000000|
|你是个大笨猪00000000000000|
|你是个超级大笨猪000000000000|

3.右对齐 rjust

for poem_str in poem:
    print("|%s|" % poem_str.rjust(20,"#"))  # 右对齐，其余地方#补全
# 结果：
|#################你是猪|
|#################辜友银|
|###############你是个笨猪|
|##############你是个大笨猪|
|############你是个超级大笨猪|
    

七、小方法

1.findall(全文查找返回):

? 1.找出字符串中符合正则的内容
? 2.返回列表，列表中是正则表达匹配的内容

res = re.findall(‘a‘,‘asd jeff ball‘)
res1 = re.findall(‘[a-z]+‘,‘asd jeff ball‘)
print(res1)

2.search(从上至下查找):

? 1.返回一个对象，必须调用group才能看到结果
? 2.根据正则查找一次，只要查到结果就不会往后查找
? 3.当查找结果不存在（返回的None），再调用group直接报错，因为none没有group方法

res2 = re.search(‘a‘,‘asd jeff ball‘)
if res2:
print(res2.group())

3.match(匹配开头):

? 1.match匹配字符串开头
? 2.没有同样返回None
? 3.同样调用group报错

res3 = re.match(‘a‘,‘asd jeff ball‘)
if res3:
print(res3.group())

4.split(切割)：

ret = re.split(‘[ab]‘, ‘abcd‘) # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割
print(ret) # [‘‘, ‘‘, ‘cd‘]

str = "abcd,ssdhu,123";
print str.split( );       # 以空格为分隔符，包含 \n
print str.split(' ,', 1 ); # 以逗号为分隔符，分隔成两个

5.sub(替换)

ret = re.sub(‘999‘, ‘H‘, ‘jeff age max 999 8884‘, 2) # 将数字替换成‘H‘，参数1表示只替换1个

print(ret) # evaHegon4yuan4

6.subn(替换，返回元组)

ret = re.subn(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘) # 将数字替换成‘H‘，返回元组(替换的结果,替换了多少次)
print(ret)

7.compile(正则封装为对象)

obj = re.compile(‘\d{3}‘) #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search(‘abc123eeee‘) #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123

8.finditer(迭代)

ret = re.finditer(‘\d‘, ‘ds3sy4784a‘) #finditer返回一个存放匹配结果的迭代器
print(ret) # <callable_iterator object at 0x10195f940>
print(next(ret).group()) #查看第一个结果
print(next(ret).group()) #查看第二个结果
print([i.group() for i in ret]) #查看剩余的左右结果

9.分组

res = re.search(‘^[1-9]\d{14}(\d{2}[0-9x])?$‘,110105199812067023
print(res)

print(res.group(1)) # 获取正则表达式括号阔起来分组的内容
print(res.group(2)) # search与match均支持获取分组内容的操作 跟正则无关是python机制

10.起别名：

re.search(‘^[1-9]?P(\d{14})(\d{2}[0-9x])?$‘,110105199812067023)
print(res.group(passwd))

数据类型及方法

原文：https://www.cnblogs.com/WQ577098649/p/11884958.html