序列类型
列表
list支持切片操作，所谓的切片则是从原list当中拷贝出指定的一段。
list[ 起始位置 : 结束位置 : 步长 ] [ 起始位置 , 结束位置 ) 左闭右开区间
li=[0,1,2,3,4,5,6]
print(li[1:3]) # Return list from index 1 to 3 => [1, 2]
print(li[2:]) # Return list starting from index 2 => [2, 3, 4, 5, 6]
print(li[:3]) # Return list from beginning until index 3 => [0, 1, 2]
print(li[::2]) # Return list selecting every second entry => [0, 2, 4, 6]
print(li[::-1]) # Return list in reverse order => [6, 5, 4, 3, 2, 1, 0]
print(li[6:3:-1])# Return list in reverse order => [6, 5, 4]
步长设置成-1则代表反向遍历,要指定一段区间倒序，则start和end也需要反过来
列表的方法
#list.append list.index list.remove
#list.count list.insert list.reverse
#list.extend list.pop list.sort
| append(...)
| L.append(object) -- append object to end
|
| count(...)
| L.count(value) -> integer -- return number of occurrences of value
|
| extend(...)
| L.extend(iterable) -- extend list by appending elements from the iterable
|
| index(...)
| L.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| insert(...)
| L.insert(index, object) -- insert object before index
|
| pop(...)
| L.pop([index]) -> item -- remove and return item at index (default last).
| Raises IndexError if list is empty or index is out of range.
|
| remove(...)
| L.remove(value) -- remove first occurrence of value.
| Raises ValueError if the value is not present.
|
| reverse(...)
| L.reverse() -- reverse *IN PLACE*
|
| sort(...)
| L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
| cmp(x, y) -> -1, 0, 1
增
append
append会将参数整个添加到列表的最后一位
append(object)
#列表 增删改查
list = [1,2,3]
list.append(4)
list.append(['加入列表'])
list.append(('加入tuple'))
print(list)
[1, 2, 3, 4, ['加入列表'], '加入tuple']
insert
insert会将参数整个添加到列表的指定位置
insert(index, object)
extend
extend会将参数的元素依次添加到列表的末尾
extend(iterable)
list.insert(1,'insert插入的元素')
list.extend('abc') #将abc拆分追加在list末尾
print(list)
[1, 'insert插入的元素', 2, 3, 4, ['加入列表'], '加入tuple', 'a', 'b', 'c']
删
clear
clear会将列表所有元素清除
clear()
pop
pop会删除指定索引位置的元素，如果没指定则删除最后一个返回该元素的值
pop([index])
list=[1,2,3,4,5]
print(list.pop())
list.pop(0) #弹出下标为0的元素
print(list)
5
[2, 3, 4]
remove
remove移除列表中第一个和参数值相同的元素
remove (object)
list=[3,4,5,5,4,3]
list.remove(4) #移除找到的第一个元素
print(list)
[3, 5, 5, 4, 3]
查
index
index从列表中寻找和参数的值相同的元素
可以指定寻找的范围 返回该元素的索引值
index(value, [start, [stop]])
print(list)
#列表查找
print(list.index(3)) #index找到第一个值为3的元素并返回下标 没找到会报错
print(list.index(4,3)) #从第3个开始找目标为4的下标并返回
print(list.index(4,2,5))#从第2个开始到5结束找到目标为4的元素并返回下标
[3, 5, 5, 4, 3]
0
3
3
count
count统计参数的值在列表中出现的次数
count(value)
其他
copy
copy返回一个新列表，新列表的元素和当前列表相同
copy()
print(list)
print('*'*20)
list_temp=list
print(list_temp)
print(id(list))
print(id(list_temp))
print('*'*20)
list_tmp=list.copy()
print(id(list))
print(id(list_tmp))
[3, 5, 5, 4, 3]
********************
[3, 5, 5, 4, 3]
2019722472328
2019722472328
********************
2019722472328
2019722516744
reverse
reverse将列表中元素的顺序倒过来
reverse()
list.reverse() #将列表倒序
print(list)
[3, 4, 5, 5, 3]
sort
sort对列表进行排序，key确认排序的数据类型，reverse是否反向
sort (key=None, reverse=False)
list=[1,5,9,7,3,6,4,8,2]
list.sort(reverse=True) #不加reverse=True从小到大排序
print(list)
[9, 8, 7, 6, 5, 4, 3, 2, 1]
补充
关于list的判断，可以用==和is来判断
a = [1, 2, 3, 4] # Point a at a new list, [1, 2, 3, 4]
b = a # Point b at what a is pointing to
print(b is a) # => True, a and b refer to the same object
b == a # => True, a's and b's objects are equal
c = [1, 2, 3, 4] # Point b at a new list, [1, 2, 3, 4]
print(c is a) # => False, a and b do not refer to the same object
c == a # => True, a's and
Python是全引用的语言，其中的对象都使用引用来表示。is判断的就是两个引用是否指向同一个对象，而==则是判断两个引用指向的具体内容是否相等。举个例子，如果我们把引用比喻成地址的话，is就是判断两个变量的是否指向同一个地址
判断元素是否在list中出现，可以使用in关键字
li = [0,1,2,3]
print(1 in li) # => True
print(4 in li) # => False
深浅复制
list_nest = ['被','嵌','套','的','链','表']
list_source = [1,2,list_nest]
print(list_nest,list_source)
list_copy = list_source.copy()
print(id(list_source),id(list_copy))
print('源地址',id(list_source[2]),'复制地址',id(list_copy[2])) #list_copy[2]和list_source[2]地址一样
import copy
list_deep = copy.deepcopy(list_source)
print("*"*30)
print(id(list_source),id(list_deep))
print('源地址',id(list_source[2]),'深复制地址',id(list_deep[2])) #list_deep[2]和list_source[2]地址不一样
['被', '嵌', '套', '的', '链', '表'] [1, 2, ['被', '嵌', '套', '的', '链', '表']]
2767446168648 2767447450120
源地址 2767446168136 复制地址 2767446168136
******************************
2767446168648 2767448195720
源地址 2767446168136 深复制地址 2767448195976
字符串的方法
str.capitalize str.endswith str.isalnum str.istitle
str.lstrip str.rjust str.splitlines str.translate
str.center str.expandtabs str.isalpha str.isupper
str.partition str.rpartition str.startswith str.upper
str.count str.find str.isdigit str.join
str.replace str.rsplit str.strip str.zfill
str.decode str.format str.islower str.ljust
str.rfind str.rstrip str.swapcase str.encode
str.index str.isspace str.lower str.rindex
str.split str.title
字符串的判断
| 方法 | 作用 | 示例 |
|---|---|---|
| isdigit | 判断所有元素是不是数字 | st1.isdigit() |
| isalpha | 判断是否没有数字 | st1.isalpha() |
| endswith | 返回是否以对象结尾 | st1.endswith() |
| startswith | 返回是否以对象开头 | st1.startswith() |
| islower | 判断是否全部小写 | st1.islower() |
| isupper | 判断是否全部大写 | st1.isupper() |
str1 = "123"
print(str1.isdigit()) #判断所有元素是不是数字
str1 = "abc"
print(str1.isalpha()) #判断是否没有数字
str1 = "abcdefg"
print(str1.endswith('g'),str1.endswith('f')) #判断是否以某对象结尾
print(str1.startswith('ab'),str1.startswith('cd')) #判断是否以某对象结尾
print(str1 .islower()) #判断是否全部小写
print(str1 .isupper()) #判断是否全部大写
输出：
True
True
True False
True False
True
False
字符串转换
| 方法 | 作用 | 示例 |
|---|---|---|
| upper | 小写字母转大写 | st1.upper() |
| lower | 大写字母转小写 | st1.lower() |
| strip | 去除字符串两边空格 | st1.strip() |
| capitalize | 字符串首字符转大写 | st1.capitalize() |
| title | 字符串中所有首字母大写 | st1.title() |
print('\n大小写转换')
s1,s2='abc','ABC123efg'
print('大写，s1.upper(),',s1.upper())
print('小写，s2.lower(),',s2.lower())
print('大小写互换 ,s2.swapcase(),',s2.swapcase())
print('首字母大写 ,s1.capitalize(),',s1.capitalize())
input
大小写转换
大写，s1.upper(), ABC
小写，s2.lower(), abc123efg
大小写互换 ,s2.swapcase(), abc123EFG
首字母大写 ,s1.capitalize(), Abc
修改
split
split会将字符串按照给定的字符进行切割，可以指定最大切割次数
split(seq=None, maxsplit=-1)
str = "abc cba"
st1 = str.split() #默认空格处切割
print(st1)
st2 = str.split('b')
print(st2)
st3 = str.split('c')
print(st3)
input:
['abc', 'cba']
['a', 'c c', 'a']
['ab', ' ', 'ba']
查找
find
find到字符串中寻找对象，可指定寻找范围；未找到返回 -1
find(object, [start, [stop]])
str = "abc cba"
st1 = str.find('b')
st2 = str.find('b',2,6) #从第二个位置开始查询到第七个位置结束
print(st1)
print(st2)
input:
1
5
替换
replace
replacr会将字符串中指定的字符替换掉，可以确定替换的次数
replace(old, new[, count])
str = "abc cba"
st1 = str.replace('b','编程学习基地') #将参数一的内容替换成参数二
拼接
| 方法 | 作用 | 示例 |
|---|---|---|
| + | 将两个字符串连接在一起 | st1 + st2 |
| join | 将字符串插入到可迭代对象的每个元素中间 | st2.join(st1) |
| %s | 用于给字符串占位 | "%s我是谁%s" % ("喂", "?") |
| {} | 用于占位 | "{}你是谁{}".format("嘿", "?") |
str = '***'
#把自身添加到可迭代对象每两个元素之间
st1 = str.join(['编','程','学','习','基','地'])
print(st1)
print('*'*30)
str = "公众号：%s，作者：%s" % ("编程学习基地","DeRoy")
str1 = "公众号：{}，作者：{}".format("编程学习基地","DeRoy")
print(str,str1)
1
5
编***程***学***习***基***地
******************************
公众号：编程学习基地，作者：DeRoy 公众号：编程学习基地，作者：DeRoy
补充
可以在字符串前面加上f表示格式操作
name = "梦凡"
print(f"他的网名叫做 {name}.")
print(f"{name} 这个名字的长度是 {len(name)}") # => "Reiko is 5 characters long."
input:
他的网名叫做 梦凡.
梦凡 这个名字的长度是 2
字符串的编码
英文 -> ASCII
中文 -> GB2312
世界 ->UNICODE
utf-8 支持中文
print(str)
print("编程学习基地".encode())
print(b'\xe7\xbc\x96\xe7\xa8\x8b\xe5\xad\xa6\xe4\xb9\xa0\xe5\x9f\xba\xe5\x9c\xb0'.decode()) #解码 默认utf-8
print(b'\xe7\xbc\x96\xe7\xa8\x8b\xe5\xad\xa6\xe4\xb9\xa0\xe5\x9f\xba\xe5\x9c\xb0'.decode("gbk")) #用gbk解码 解码失败
print(b'\xe7\xbc\x96\xe7\xa8\x8b\xe5\xad\xa6\xe4\xb9\xa0\xe5\x9f\xba\xe5\x9c\xb0'.decode("utf-8")) #默认utf-8
input:
b'\xe7\xbc\x96\xe7\xa8\x8b\xe5\xad\xa6\xe4\xb9\xa0\xe5\x9f\xba\xe5\x9c\xb0'
编程学习基地
缂栫▼瀛︿範鍩哄湴
编程学习基地
元组的方法
tuple和list非常接近，tuple通过()初始化。和list不同，tuple是不可变对象。也就是说tuple一旦生成不可以改变。如果我们修改tuple，会引发TypeError异常。
| 方法 | 作用 | 示例 |
|---|---|---|
| index | 查看索引 | 省略 |
| count | 统计个数 | 省略 |
Tuple = (1,2,3,4,1,1)
count =Tuple.count(1) #元组中元素'1'个数量
print(Tuple.index(2),count) #index所有下标从1开始
1 3
