Python基础--字符串+列表

前言：

Python中常见可变类型有：字典(dic),列表(list)

Python中常见不可变的类型有：数字,字符串(str),元组(tuple)

列表的操作

1-list添加元素：

Append（）与extend（）的区别：

Append（）添加的是***单个元素***，也可以是列表、元组等，整个整体放入后边。

Extend（）添加的是将***单个元素***，列表、元组进行***拆分***，单个放入后边。

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

insert():在列表中间某个位置插入元素，那么可以使用 insert() 方法，主要用来在列表的中间位置插入元素，如果你仅仅希望在列表的末尾追加元素

1.1-Append():

append的用法：
a = [40,20,30]
b = [15]
c = (12)
1.追加元素
append a(2)
print(a)   输出：[40,20,30,2]
2.追加列表
a.append(b) 输出：[40,20,30,[15]]
3.追加元组
a.append(c) 输出：[40,20,30,(12)]

1.2-Extend():

extend的用法：
a = ['c++','python','hh']
b = ('java','http')
c = ['add','suger']
1.追加元素
a.append('o')
print(a) 输出：['c++','python','hh','o']
2.追加列表
a.append(b) 输出：['c++','python','hh','java','http']
3.追加元组
a.append(c) 输出：[['c++','python','hh','add','suger']

1.3-Insert():

insert() *下标* 用法：
a = ['c++','python','hh']
b = ('java','http')
c = ['add','suger']
1.下标插入元素
a.insert(1,'go')
print(a) 输出：['c++','go','python','hh']
2.插入元组，整个列表被当成一个元素
a.insert(2,b)
print(a) 输出：['c++','python','hh'，('java','http')]
3.插入列表，整个列表被当成一个元素
a.insert(1,c)
print(a) 输出：['c++','python',['add','suger']，'hh']
4.插入字符串，整个字符串被当成一个元素
a.insert(0,'http://www.baidu.com')
print(a) 输出：['http://www.baidu.com'，'c++','python','hh']

2-list删除元素:

2.1-Del()

del()是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

lang = ['c++','python','hh','go']
1.使用正数索引删除
del lang[3]
print(lang) 输出:['c++','python','hh']
2.使用负数索引删除
del lang[-2]
print(lang) 输出：['c++','hh','go']
3.使用索引删除一段连续的元素
del lang[0:3]
print(lang) 输出：['go']

2.2-Pop()

pop() 方法用来删除列表中指定索引处的元素,如果不写参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作

nums = [40, 36, 89, 2, 36, 100, 7]
1.删除下标为3的索引
nums.pop(3)
print(nums) 输出：[40, 36, 89, 36, 100, 7]
2.不指定索引
nums.pop()
print(nums) 输出：[40, 36, 89, 2, 36, 100]

2.3-Remove()

根据元素值进行删除,remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

nums = [40, 36, 89, 2, 36, 100, 7]
1.第一次删除36
nums.remove(36)
print(nums) 输出：[40, 89, 2, 36, 100, 7]
2.第二次删除36
nums.remove(36)
print(nums) 输出：[40, 89, 2,100, 7]
3.删除78
nums.remove(78)
print(nums) 输出：ValueError: list.remove(x): x not in list（）最后一次删除，因为 78 不存在导致报错，所以我们在使用 remove() 删除元素时最好提前判断一下

2.4-Clear()

Python clear() 用来删除列表的所有元素，也即清空列表。

url = list("http://c.biancheng.net/python/")
url.clear()
print(url) 输出：[]

3-list查找元素：

3.1-ndex（）

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
1.检索列表中的所有元素
print( nums.index(2) ) 输出：3
2.检索3~7之间的元素
print( nums.index(100, 3, 7) ) 输出：5
3.检索4之后的元素
print( nums.index(7, 4) ) 输出：6
4.检索一个不存在的元素
print( nums.index(55) ) 输出：ValueError: 55 is not in list

3.2-Count（）

count() 方法用来统计某个元素在列表中出现的次数

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
1.统计元素出现的次数
print("36出现了%d次" % nums.count(36)) 输出:36出现了3次
2.判断一个元素是否存在
if nums.count(100):
    	print("列表中存在100这个元素")
    else:
     	print("列表中不存在100这个元素")
输出：列表中存在100这个元素

4-list中队和栈的用法：

1. 队：定义一个 list 变量，存入数据时使用 insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据；读取数据时，使用 pop() 方法，即将队列的最后一个元素弹出。list 列表中数据的存取顺序就符合***“先进先出”**的特点

   #定义一个空列表，当做队列
   queue = []
   #向列表中插入元素
   queue.insert(0,1)
   queue.insert(0,2)
   queue.insert(0,"hello")
   print(queue) 输出：['hello','2','1']
   print("取一个元素：",queue.pop()) 输出：[取一个元素: 1]
   print("取一个元素：",queue.pop()) 输出：[取一个元素: 2]
   print("取一个元素：",queue.pop()) 输出：[取一个元素: 'hello']
   

2. 栈:使用 list 列表模拟栈功能的实现方法是，使用 append() 方法存入数据；使用 pop() 方法读取数据。与队相反，其特点**“后进先出”**

   #定义一个空列表，当做队列
   queue = []
   #向列表中插入元素
   queue.insert(0,1)
   queue.insert(0,2)
   queue.insert(0,"hello")
   print(queue) 输出：['1','2','hello']
   print("取一个元素：",queue.pop()) 输出：[取一个元素: 'hello']
   print("取一个元素：",queue.pop()) 输出：[取一个元素: '1']
   print("取一个元素：",queue.pop()) 输出：[取一个元素: '2']
   

3. collections模块实现队和栈:使用标准库的 collections 模块中的 deque 结构体，它被设计成在两端存入和读取都很快的特殊 list，可以用来实现栈和队列的功能。

   queueAndStack = deque()
   queueAndStack.append(1)
   queueAndStack.append(2)
   queueAndStack.append("hello")
   print(list(queueAndStack)) 输出:[1, 2, 'hello']
   1.实现队列功能，从队列中取一个元素，根据先进先出原则，这里应输出 1
   print(queueAndStack.popleft()) 输出:1
   2.实现栈功能，从栈里取一个元素，根据后进先出原则，这里应输出 hello
   print(queueAndStack.pop()) 输出:hello
   3.再次打印列表
   print(list(queueAndStack)) 输出：[2]
   

字符串的用法

1-表达方式

python中字符的表达方式
a = 'hello' 可以是单引号
b = "hello" 可以是双引号
c = '''hello''' 也可以说是三引号
d = "hello:'heiei',ahahaha"  在多个句子中要同时使用单双的时候必须 单双引号同时用不能**双单引号** **双双引号**

2-下标和切片

**下标取值**
a = 'helloyoyo'  #我们要取出这个字符串中的某一个字母，我们采用下标取值的方法。
#语法 ==>  a[index] ==> 获取指定下标的数据
print(a[2])  输出：l
**切片**
#语法 ==> a[start:end:step]  起始位置：结束位置：步长
**注意** 包含头不包含结尾 左闭右开区间
print(a[1:3])  输出：el

3-字符串常见的操作

3.1:获取长度

len()函数可以获取字符串里面的长度

a ='今天天气好好啊'
print(len(a)) 输出：7

3.2:查找内容

find(),index(),rfind(),rindex() 可以获取指定字符的下标

b = 'abcdefjhijkd'
find() and rindex() 寻找下标值最小的输出
1.find(): #如果字符串不存在你要查找的人值，那么将会的结果是-1
print(a.find('i')) 输出：8
print(a.find('m')) 输出：-1
2.index():#如果字符串不存在你要查找的人值，那么将会的结果会报错
print(a.index('f')) 输出:5
print(a.index('m')) 输出: substring not found
3.rfind() and rindex 查找下标值最大的数输出
print(a.rfind('d')) 输出：11
print(a.rindex('d')) 输出：11

3.3:判断

startswith(),endswith(),isalpha(),isdigit(),isalnum(),isspance()

# is开头的，返回的结果都是布尔类型
1.startswith():判断字符串是以什么开头的 and endswith():判断字符串是以什么结尾的
a = 'hello'
b = '123'
c = '123hello'
print(a.startswith('h'))  输出：True
print(a.endswith('o'))  输出：True
2.isalpha():判断字符串里面是否全为全英文 and isdigit()：判断字符串里面是否全为数字
print(a.isalpha()) 输出：True
print(b.isalpha())  输出：False
print(a.isdigit())  输出：False
print(b.isdigit())  输出：Fasle

3.4:其他用法（所罗列的都是常用的）

• 替换内容：replace()

• 计算出现的次数：count()

• 切割字符串：split(),rsplit(),splitlines(),partition(),rpartition()

• 修改大小写：capitalize(),title(),upper(),lower(),swapcase()

• 空格处理：ljust(),rjust(),center(),lstrip(),rstrip(),strip()

• 字符串连接：join(）

3.4.1:replace替换内容

"""
A.relpace('c','b'):
	将字符串A中的所有c替换为b
"""
strs = '我爱我的中国'
print(strs.replace('我的','你')) 输出：我爱你中国

3.4.2：count计算次数

strs = '唧唧复唧唧木兰开飞机'
print(strs.count('唧')) 输出：4

3.4.3 : 切割字符串常用

"""
A.split():
	将字符串A分割返回的数据存储到列表
	默认是以空白符分割
"""
print(strs1.split('木兰')) #['唧唧复唧唧木兰','开飞机开 的什么机波音柒四柒']

print(strs1.split()) # ['唧唧复唧唧木兰开飞机开的什么', '机波音柒四柒']

3.4.4:修改大小写

"""
A.capitalize():
	将字符串A的首字母变为大写,其余单词的首字母变为小写
"""
strs6 = 'life is short. I learned Python'
print(strs6.capitalize()) # Life is short. i learned python

"""
A.title():
	将字符串A的每个单词的首字母变为大写
"""
print(strs6.title()) # Life Is Short. I Learned Python

"""
A.upper() A.lower():
	将字符串A中的所有字母转为大写
	将字符串A中的所有字母转为小写
"""
print(strs6.upper())    #LIFE IS SHORT. I LEARNED PYTHON
print(strs6.lower())    # life is short. i learned python

"""
A.swapcase():
	将字符串A中的所有字母大写转为小写小写转为大写
"""
strs7 =  'Life is short, I learned Python'
# print(strs7.swapcase()) # lIFE IS SHORT, i LEARNED pYTHON

3.4.5:字符串拼接

"""
A.join():
	作用与split方法相反
	可以将split分割的数据拼接起来
	拓展：使用字符串拼接符+，会生成新的字符串不推荐使用+来拼接字符串
"""
strs5 = ['我爱你','我的中国']
# print(','.join(strs5)) # 我爱你,我的中国

4-字符串格式化

4.1 %格式符

# 以元组的方式进行参数传入，值需一一对应
print('我叫%s,今年%d岁了'%('王华',19)) # 我叫王华,今年19岁了

常见的格式符有

符号	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数
%u	格式化无符号整数

4.2 字典形式

"""
相比%格式符字典形式不需要一一对应，命名使用()括起来，每个命名对应一个key
"""
print('我叫%(name)s,今年%(age)d岁了'%{'name':'王华','age':19}) # 我叫王华,今年19岁了

4.3 format

"""
可以接受不限参数个数，位置可以不按顺序
"""
# 1.根据框对应值
"{} {}".format("hello",'word') # hello word
# 2.根据索引指定对应框的值
"{1} {0} {0}".format("hello","word") # word hello hello

"""
设置参数
"""
# 1.类似字典形式
"姓名:{name},职业:{pos}".format(name = '孙尚香',pos='射手') # 姓名:孙尚香,职业:射手
# 2.通过字典设置参数
info_dict = {"name":"盲僧","pos":"战士"}
"姓名:{name},职业:{pos}".format(**info_dict) # 姓名:孙尚香,职业:射手
# 3.通过列表索引设置参数
info_list = ["剑姬","石头"]
info_list1 = ["战士","刺客"]
"姓名:{0[1]},职业:{1[0]}".format(info_list,info_list1) # 姓名:石头,职业:战士
# 姓名中的0是format中的索引下标，[1]对应列表列表里面索引为1的值

"""
数字格式化
"""
c = 3.1415926
b = 15
d = -12
e = 100000
f = 0.28
# 1. 保留2为小数 f:浮点数
'{:.2f}'.format(c) # 3.14
# 2. 居中 10:表示10个字符的长度(不设置看不出来效果)   d:十进制
'{:^10d}'.format(b) #      15
# 3. 向左向右
'{:>10d}'.format(b) # 15 
'{:<10d}'.format(b)#           15
# 4. 输出进制数
'{:b}'.format(b) # 1101
'{:o}'.format(b) # 17
'{:x}'.format(b) #  f
# 5. 显示正负号
'{:+}'.format(b) # +15
'{:-}'.format(d) # -12
# 6. 空格
'{: }'.format(b) #  15
# 7. 千分符
'{:,}'.format(e) # 1,000,000
# 8. 百分号
'{:.2%}'.format(f) # 28.00%
# 组合使用 填充符配合使用[注]:在：后面首位
'{:+.2f}'.format(c) # +3.14
'{:*>5d}'.format(b) # ***15
'{:x<9d}'.format(b)#   15xxxxxxx

数字格式符号有

符号	描述
^	居中对齐
>	左对齐
<	右对齐
:	数字格式化必须先写:,:号后面带填充的字符，只能是一个字符，不指定默认空格
b,d,o,x	b:二进制；d:十进制; o:八进制; x:十六进制;
+	表示整数前面显示+，负数前显示-
空格	表示正数前面加空格
，	数字的千位分隔符适用于整数和浮点数
.	精度，表示小数部分输出的有效位数，对于字符串表示输出的最大长度
%	输出的浮点数以百分形式
f	输出的浮点数的标准浮点形式

4.4 f-string

# 字面量格式化
num = 'word'
# {}括号里的命名必须与变量名一致
cc = f'hello,{num}'
print(cc) # hello,word