python基础-字符串、列表、元组、字典、集合

最新推荐文章于 2025-04-06 15:04:04 发布

loco_python

最新推荐文章于 2025-04-06 15:04:04 发布

阅读量1.8k

点赞数 2

分类专栏： python基础文章标签：字符串元祖列表字典集合

本文链接：https://blog.youkuaiyun.com/weixin_40304570/article/details/79379722

版权

python基础专栏收录该内容

11 篇文章

订阅专栏

一、字符串

（一）字符串的介绍

简单的字符串：双引号或者单引号之间的数据，就是字符串

print("Let's go")
print("Let\'s go")   # \'用来转意

原始字符串：

str1 = "C:\naaa\nbbb\nccc"
print(str1)      # 想打印出目录，\n默认为换行
str1 = r"C:\naaa\nbbb\nccc"
print(str1)      # 前面加一个R能起到打印字符串的作用

（二）字符串的下标索引和切片

字符串索引、替换

str1 = "abcdef"
print(str1[0])   #打印出第一个字符
print(str1[2])
# 将字符串中的'a'改为0
str1[0] = "0"    #不能直接用下表替换，会报错。
print(str1)
# 只能用replace替换,replace(str1,str2)将字符类型的str2替换成str1
print(str1.replace("a","0"))
print(str1)      #原字符串不变

字符串的切片

str1 = '1234567890'
# 截取字符串最后三位的字符
print(str1[7:])
print(str1[-3:])     #为设定步进的时候，步进默认为1，从左往右
# 截取字符串的全部字符
print(str1[:])F
# 截取字符串的倒数第一个字符
print(str1[-1])
# 截取与原字符串顺序相反的字符串
print(str1[::-1])         #快速将字符串逆置
# 截取字符串倒数第三位与倒数第一位之前的字符
print(str1[-3:-1])
# 截取086。
print(str1[:4:-2])
当[a：b：c]   当a决定C

（三）字符串的查找与检查（find(), index(),count()）

str1 = "you are my firends"
# find() 检查字符串是否包含在str1中，如果在返回开始索引值，否则返回-1
print(str1.find("are"))            # a = 4   返回值需要赋给变量名
# index() 和find()一样，只不过会报错
# count(str,start,end) 返回字符串在开始和结尾之间在st1中出现的次数
print(str1.count("e"))    #如果没设置开始和结尾则默认真个字符串中
print(str1.count("e",7,12)) #如果去掉12则默认为7到字符串末端
# rfind()      #从右边开始查找，在查找文件的后缀时可以用
# rindex()   #从右边开始索引

（四）字符串的判断

str1 = "we are friends"
# isalpha() 如果str1中所有字符都是字母，返回True
print(str1.isalpha())       #False  因为有空格
# isdigit() 如果str1中所有字符都是数字，返回True
# isalnum() 如果str1中所有字符是数字或者字母，返回True
# isspace() 如果str1中所有字符都是空格，返回True
# startswith(we) 检查we是否在字符串str1中以开头出现，返回bool
# endswith(friends) 检查friends是否在字符串str1中以结尾出现，返回bool

（五）字符串修改

str1 = "we are friends"
# split(str，a) 以str为分隔符切片str1，如果a有指定值，则仅分割a个子字符串
# splitlines()  按照行分隔符，返回一个包含各元素的列表
# capitalize() 把t字符串第一个字符大写
# title()  把字符串的每个单词首字母大写"We Are Friends"
# lower()  把所有字符串的大写字符小写
# upper()  把字符串所有小写字母大写
# ljust(width)  返回一个原字符串左对齐，使用空格填充至长度width的新字符串
# rjust(width)  返回一个原字符串右对齐，使用空格填充至长度width的新字符串
# center(width) 返回一个原字符串居中，并使用空格填充至长度width的新字符串
# lstrip()  删除str1左边的空格
# rstrip()  删除str1右边的空格
# strip()  删除str1两端的空格
# partition(str)  将str1分割成为前中后三部分
# rpartition(str)  从右开始将str1分割成为前中后三部分
# join(list)    str1每个元素后面插入str2构造成一个新的字符串
str2 = "_"    将列表中的字符串一“ ”方式写成新的字符串
print(str2.join(str1))

二、列表

（一）列表的特点和创建

1、可以对不同类型数据储存，但是要避免储存多种数据类型
list1 = [1,2,”曹哲”,(1,2,3,4)] list1 = []
2、和str一样可以索引和切片
索引出list1中的4：list1[3][3]
3、迭代。for i in list1::
print(i)
4、renge(10)
5、列表和普通变量的区别：列表是数据类型，普通列表是用来存储数据的，可以把列表复制给普通变量。
6、列表的缺点：①在头部或者其他部分添加元素，效率比较低。
②根据某个特征查找元素，效率非常低。
字典能满足他！！！
7、列表不能作为字典和集合的元素。。。

（二）列表添加元素

list1 = [1,2,3,4]
#### insert(index,object)  在指定位置index前插入元素object.
list1.insert(2,5)
#### 列表是可变的，所以插入后还是返回原列表
print(list1)
## append() 再末尾追加一个任何类型的数据
list1.append([1,2,3,4])
print(list1)
## extend()  在列表末尾追加数据，如果是列表或元祖，拆分后将追加到列表里
list1.extend((6,7))  # extend()中的元素必须为可迭代对象
print(list1)

（三）列表修改和删除元素

list1 = [1,2,3,4,[5,6,7],8]
# 修改，根据元素下标直接赋新值，如果不知道下标，用index()索引获得
list1[4][2] = 0         #打印list1
list1[list1.index(4)] = 10               #打印list1
# remove()  删除列表内指定的数据  
list1.remove(2)         #打印list1
# pop()  删除列表中指定的下标的数据，并返回该数据，（如果没有参数，则默认最后的数据）
print(list1.pop())      #打印list1
# clear() 清除列表所有数据，但不删除列表。
list1.clear()           # 打印list1
# del Python提供的删除方式，可以删除任何数据
del list1

（四）查找列表元素

list1 = [1,2,3,4,[5,6,7],8]
# in 和 not in 判断元素是否存在列表，字符串，元组里
# index(元素，开始，结束)  返回列表里指定元素的下标（如果没有，报错）
print(list1.index(3,1,4))
# count(元素，开始，结束)  返回列表里指定元素个数

（五）列表排序和倒置

list1 = [1,3,2,4,0]
# sort()  Python列表提供的方法，在原列表上排序，Python2支持混合列表排序，3只支持统一类型排序
list1.sort()         #打印list1
# sorted()  BIF Python提供的方法，返回新列表，原列表不变
print(sorted(list1))
# reverse()  将列表倒置。
list1.reverse()        #打印list1
# sorted(list1,reverse = True)     #返回一个新的列表
print(sorted(list1,reverse = True))
list2 = list(reversed(sorted(list1)))

（六）列表的拷贝

list1 = [1,3,2,4,0]
# 引用  （浅拷贝）：只是增加了一个原数据的引用，地址不变
list2 = list1                 #他们的地址一样。
if id(list2) == id(list1):    #若改变list2，也改变list1。没有真正实现拷贝
    print("浅拷贝")
# copy()深拷贝  拷贝一个分数据给新列表，和原列表没有任何关系
list2 = list1.copy()    #打印list2
# 用切片的方式复制（相当于copy.deepcopy()）
list2 = list1[:]

（七）列表推倒式

# 将一段代码写成推倒式
list2 = []
for i in range(1,21):
    if i % 2 == 0:
        list2.append(i)
print(list2)
# 在表达式中for遍历一般与if一起用
# 先执行for 循环。
list1 = [i for i in range(1,21) if i % 2 == 0]
print(list1)
# 如果返回值和没有遍历值：生成10个“666”的列表
# list3 = ["666" for i in range(0,10)]
# i 只是起到遍历，没有起到判断值或者返回值的作用，可以用下划线代替
list3 = ["666" for _ in range(0,10)]
print(list3)

（八）列表的常用技巧

列表合并：

list1 = [1,2,3,4]
list2 = [5,6,7,8]
# 返回一个新列表list3
list3 = list1 + list2    #print(list3)
# 如果是用list1 += list2 在原列表追加，不生成新列表（列表可变）
list1 += list2           #print(list1)

将字符串转列表：

mystr = "we are friends"
# 可以用split()先将mystr分割成三个字符串的列表
print(mystr.split(" "))
# 如果直接用list强制转换，则会使得每一个字符成为一个列表元素
print(list(mystr))

将列表转为字符串：

list1 = ['we', 'are', 'friends']
# " ".join()    把谁谁谁加入到（list）
print(" ".join(list1))   #只能转列表的每一个元素都为字符串
list2 = [10,20,30]
# 那么如何将list2转为字符串？
# 首先应该先将list2中的每个元素转为字符型,返回成列表，再进行转化
print(" ".join([str(i) for i in list2]))

内置函数（BIF）：

list1 = [10,20,30,40]
# isinstance()  内置函数，判断对象是否为指定类型，返回True
if isinstance(list1,list):
    print("list1是列表")
if isinstance(list1[1],int):
    print("列表中第二个元素是整形")
# enumerate(列表，元祖，字符串等)   获取列表的元素下标和元素，返回一个列表
list(enumerate(list1)) 
for x,y in enumerate(list1):
    print(x,y)

（九）列表的嵌套及应用

# 一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
import random;
offices = [[],[],[]]          #   三个办公室
names = ["A","B","C","D","E","F","G","H"]     
# 8位老师
# 现在我们要定一个教室的随机分配,一次提取names中的元素放入到教室里
for name in names:
    index = random.randint(0,2)
    offices[index].append(name)
i = 1
for tempName in offices:
    print("第%d个教室有%d名老师。"%(i,len(tempName)))
    i += 1

三、元组

（一）元组的特点

   **元祖不可以更改，用（，）表示**

（二）元祖的创建、查询与统计

# range()  创建元组
a = tuple(range(10,20,2))
print(a)
# 读取元组下标，找到元组元素
print(a[1])
# index() 返回值指定元素的下标（如果没有，报错）
print(a.index(12))
# count() 统计指定元素个数
print(a.count(12))

四、字典

（一）字典的基本使用

 字典查找要比列表速度快，字典和元素个数没关系。    
# ①设计字典，键一般用字符串表示。
#   字典是由键值对和花括号组成
#   字典的每个元素由2部分组成，键:值。
#   字典没有牵引，不能通过下标取值，只能通过键名来取值
num_dict = {"name":"python","age":36,"id":10}
print(num_dict["name"])

# ②创建字典
num_dict = {}
a = num_dict.fromkeys("abcd",10)
####{'a': 10, 'b': 10, 'c': 10, 'd': 10}

# ③长度
print(len(a))   #   4

（二）字典修改元素和数据添加

# ①根据键名修改元素
name_dict = {}
name_dict["name"] = "python"  #如果字典里没有键，则创建这对键值
print(name_dict)              #{'name': 'python'}
name_dict["name"] = "lihua"   #如果字典里有这个键，改变这个键的值
print(name_dict)              #{'name': 'lihua'}

# ②setdefault()
name_dict = {"name":2}
name_dict.setdefault("name")  #如果键不在字典里，则返回默认值NONE，并创建
print(name_dict)              #{'name': None}
name_dict.setdefault("name",1)  #如果键不在字典里，则返回默认值1，并创建这对键值
print(name_dict)                #{'name': 1}
print(name_dict.setdefault("name")) #如果键在字典里，则返回值Value

# get() 和setdefault基本一样。不同的是get()不会添加键值对
info = {'name': '班长', 'id': 100, 'sex': 'f'}
print(info.get("tess"))      #如果没有这个键，则返回None
print(info)                  #没有将返回的键值添加到info里
# ③keys()  返回这个字典所有键的列表
info = {'name': '班长', 'id': 100, 'sex': 'f'}
print(info.keys())        # dict_keys(['name', 'id', 'sex'])

# ④values()  返回这个字典所有值的列表
print(info.values())      # dict_values(['班长', 100, 'f'])

# ⑤items(）   返回这个字典所有键值对（元祖）的列表
print(info.items())       #dict_items([('name', '班长'), ('id', 100), ('sex', 'f')])

（三）字典拷贝,更新与删除

# ①copy()   拷贝
info = {'name': '班长', 'id': 100, 'sex': 'f'}   #对象id发生变化
print(info.copy())        #   {'name': '班长', 'id': 100, 'sex': 'f'}

# update()  字典更新，替换成新增
info_dict = {"name":"python","age":14}
new_info_dict = {"name":"hello","id":123,"age":1233}
info_dict.update(new_info_dict)     # 跟新new_info_dict到info_dict..
print(info_dict)

# ②pop() 参数是键，删除指定的键值对，并返回值
print(info.pop("name"))    # 班长
print(info.pop("sss"))     # 报错

# ③popitem() 依次从后向前删除键值对，并返回这个键值对的元组
print(info.popitem())         # 删除的返回值('sex', 'f')

# ④clear() 清空字典
# ⑤del(info)  删除字典

（四）字典推导式

# # 类似于列表，只是用花括号，返回的参数为键值对。
new_dict = {i : i**2 for i in range(1,5)}
print(new_dict)        #  {1: 1, 2: 4, 3: 9, 4: 16}

# # 将两个列表合并为字典
list1 = ["name","age","id"]
      list2 = [4,5,6]     #怎么拿出"name"
new_dict = {list1[i]:list2[i] for i in range(len(list1))}
print(new_dict)     #{'name': 4, 'age': 5, 'id': 6}

# # 将一个字典转换为列表。
new_dict = {"name":"python","old":1}
list1 = []
      for key in new_dict.keys():
     list1.append(key)
for value in new_dict.values():
     list1.append(value)

# 字典键值对互相转换
new_dict = {"name":"python","old":1}
print({value : key for key,value in new_dict.items()})

（五）字典补充

在python2中dict.has_key(key)用来判断dict中是否存在键key(python2中)。返回True。
python2中 dict.keys或者dict.items,dict.values 返回的是列表。而python3返回的是dict_keys([‘yellow’, ‘red’, ‘green’])

五、集合

（一）集合的创建和特点

# ①集合、列表、元组可以互相转换
# ②集合中的数据都是唯一的，去重的最快方式是集合
new_set = {1,2,3,4,3,2,4,5}
print(new_set)      #{1, 2, 3, 4, 5}   自动排重
# ③如果需要，一般集合会转列表做复杂的操作，再转为集合
# ④创建一个空集合
new_set = set()

（二）集合添加数据，删除数据

# add()  向集合里添加一个元素
new_set = {1,2,3,4,5}
new_set.add(6)
#####字典结合都是无序的，不能索引，集合本身不能排序，如果想排序需转成列表方式

# update()  向集合中添加多个数据，参数是一个列表
new_set = {1,2,3,4,5}
new_set.update([1,2,5,6])    #{1, 2, 3, 4, 5, 6}

# remove() 删除指定的数据，数据不存在则把报错
# discard() 本意有抛弃的意思 删除指定数据，数据不存在则不做任何操作
#  pop()   无参数默认，则从前往后依次摘除
new_set = {1,2,3,4,5}
print(new_set.pop())

（三）集合的数学运算

#  交集
a = {1,2,3,4}
b = {2,3,4,5}
print(a & b)       #  {2, 3, 4}

# 并集
print(a | b)       #  {1, 2, 3, 4, 5}

# 差集
print(a - b)       # a - b  剩下a有b没的  {1}
print(b - a)       # b - a  剩下b有a没的  {5}

# 对称差集
print(b ^ a)       #  {1, 5}

# b是否是a的子集
b <= a

# a是否是b的子集
b >= a

# 优先级
差集 > 交集 > 并集