python学习三：列表，元组

序列类型

列表

列表的方法

#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支持切片操作，所谓的切片则是从原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_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()

字符串转换

方法	作用	示例
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())

大小写转换
大写，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)

查找

find

find到字符串中寻找对象，可指定寻找范围；未找到返回 -1

find(object, [start, [stop]])

str = "abc cba"
st1 = str.find('b')
st2 = str.find('b',2,6)   #从第二个位置开始查询到第七个位置结束
print(st1)
print(st2)

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."

字符串的编码

英文 -> 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())
print(b'\xe7\xbc\x96\xe7\xa8\x8b\xe5\xad\xa6\xe4\xb9\xa0\xe5\x9f\xba\xe5\x9c\xb0'.decode("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

元组的方法

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