python基础Ⅱ（字符串操作、列表操作、元组操作、字典操作、集合操作、共用方法、可变与不可变类型）

墨蓝 2022-12-17 07:19 146阅读 0赞

# 一、序列 #

所谓**序列**，指的是一块可存放多个值的**连续内存空间**，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们

在 Python 中，序列类型包括**字符串、列表、元组，他们支持索引、切片**。第一个索引若为**0**，则**指向左端**；第一个索引若为**负数**，则**指向右端**

**切片**是**指截取序列中的其中一段内容**。使用语法：**\[起始下标：结束下标：步长\]**，截取的内容**不包括结束下标**对应的数据，步长是指隔几个下标截取一个项（默认为1）

# 二、字符串操作 #

### 字符串格式化操作 ###

str_a = '{} {}'.format(111, 222)
    str_b = '%d %d' % (111, 222)
    
    print(str_a)
    print(str_b)
    # 输出结果
    111 222
    111 222

### capitalize() ###

将**字符串**的**第一个字母变成大写,其他字母变小写**

> str.capitalize()

test1 = 'i lovE python'
    
    print(test1.capitalize())		# 输出 I love python

### title() ###

**返回"标题化"的字符串**,就是说所有单词都是以大写开始，其余字母均为小写。还有**istitle()函数**可以检测**字符串里面的每个单词的首字母**是否为**大写**

> str.title()

str1 = "this is string example....wow!!!"
    
    print(str1.title())

### lower()/upper() ###

**转换字符串中所有大(小)写字符为小写(大)。**

> str.lower()  
> str.upper()

test1 = 'i LOVE python'
    test2 = 'i love python6*'
    
    print(test1.lower())		# i love python
    print(test1.upper())		# I LOVE PYTHON
    print(test2.lower())		# i love python6*
    print(test2.upper())		# I LOVE PYTHON6*

### swapcase() ###

**对字符串的大小写字母进行转换。**

> str.swapcase();

test1 = 'i LOVE python'
    test2 = 'i love python6*'
    
    print(test1.swapcase())		# I love PYTHON
    print(test1.swapcase())		# I love PYTHON
    print(test2.swapcase())		# I LOVE PYTHON6*
    print(test2.swapcase())		# I LOVE PYTHON6*

--------------------

### endswith() ###

用于**判断字符串是否以指定后缀结尾**，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

> str.endswith(suffix\[, start\[, end\]\])

*  suffix – 该参数可以是一个字符串或者是一个元素。
 *  start – 字符串中的开始位置，**从0开始。**
 *  end – 字符中结束位置，**最大为字符串长度。**

test1 = 'i love python'				# 13个字符
    
    print(test1.startswith('i', 0, 13))			# True，start从0开始
    print(test1.startswith('i', 1, 13))			# False
    print(test1.endswith('on', 0, 13))			# True，end为字符串长度，但不包括最后一个
    print(test1.endswith('on', 0, 12))			# False

### startswith() ###

用于**判断字符串是否以指定后缀结尾**，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

> str.endswith(suffix\[, start\[, end\]\])

*  suffix – 该参数可以是一个字符串或者是一个元素。
 *  start – 字符串中的开始位置，**从0开始。**
 *  end – 字符中结束位置，**默认为字符串的长度。**

### lstrip()/rstrip()/strip() ###

**截掉字符串左边（右边或头尾）的空格或指定字符。**  
注意：strip方法只能删除开头或是结尾的字符，不是删除中间部分的字符。

> str.lstrip(\[chars\])，默认截取的是空格  
> str.rstrip(\[chars\])，默认截取的是空格  
> str.strip(\[chars\])，默认截取的是空格

*  chars --指定截取的字符。

test1 = ' i LOVE python '
    test2 = '88888i love python88888'
    
    print(test1.lstrip())			# i LOVE python ，后面有三个空格
    print(test1.rstrip())			# i LOVE python，前面有三个空格
    print(test1.strip())			# i LOVE python
    print(test2.lstrip('88888'))			# i love python88888
    print(test2.rstrip('88888'))			# 88888i love python
    print(test2.strip('88888'))			# i love python
    
    msg = ' 22 '
    print(msg.rstrip())				# 默认截取的是空格
    print(msg.lstrip())
    print(msg.strip())

--------------------

### find() ###

**是从字符串左边开始查询子字符串匹配的第一个索引** ，如果指定 start（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，**如果包含子字符串返回第一个索引值，否则返回-1。**  
**rfind()是从字符串右边开始查询字符串匹配到的第一个索引，不过**没有**lfind()**

> str.find(str, beg, end)

*  str – 指定检索的字符串
 *  start – 开始索引，**默认为0。**
 *  end – 结束索引，**默认为字符串的长度。**

test1 = 'i love python'				# 13个字符
    
    print(test1.find('i', 0, 13))		# 0
    print(test1.find('i', 1, 13))		# -1
    print(test1.find('on', 0, 13))		# 11，为查询到的字符串的首个索引
    print(test1.find('on', 0, 12))		# -1

### index() ###

**用于从字符串中找出某个值第一个匹配项的索引位置，它与find()一样，只不过如果str找到就会爆出异常**  
**rindex()** 是 **从字符串右边开始查询字符串匹配到的第一个索引，不过** **没有lindex()**

> str.index(x\[, start\[, end\]\])

*  x-- 查找的对象。
 *  start-- 可选，查找的起始位置。
 *  end-- 可选，查找的结束位置。

str1 = 'hello world'
    
    print(str1.index('e'))			# 1
    print(str1.index('e', 1, 4))	# 1
    print(str1.index('o', 1, 5))	# 4
    print(str1.index('o', 1, 4))	# 报出异常

### replace() ###

**把字符串中的 old（旧字符串） 替换成 new(新字符串)**，如果指定第三个参数max，则替换不超过 max 次。

> str.replace(old, new\[, max\])

*  old – 将被替换的子字符串。
 *  new – 新字符串，用于替换old子字符串。
 *  max – 可选字符串, 替换不超过 max 次

str1 = "this is string example....wow!!! this is really string"
    
    print(str1.replace("is", "was"))		# thwas was string example....wow!!! thwas was really string
    print(str1.replace("is", "was", 3))		# thwas was string example....wow!!! thwas is really string

--------------------

### isalnum() ###

检测**字符串（不能有空格）是否由字母或数字组成。**

> str.isalnum()

test1 = 'i love python666'
    test2 = 'python666'
    test3 = 'python'
    test4 = '666'
    test5 = '---'
    
    print(test1.isalnum())		# False，有空格
    print(test2.isalnum())		# True
    print(test3.isalnum())		# True
    print(test4.isalnum())		# True
    print(test5.isalnum())		# False

### isalpha() ###

**检测字符串是否只由字母组成。**

> str.isalpha()

test1 = 'i love python666'
    test2 = 'python666'
    test3 = 'python'
    test4 = '666'
    test5 = '---'
    
    print(test1.isalpha())		# False
    print(test2.isalpha())		# False
    print(test3.isalpha())		# True
    print(test4.isalpha())		# False
    print(test5.isalpha())		# False

### isdigit() ###

**检测字符串是否只由数字组成。**

> str.isdigit()

test1 = 'i love python666'
    test2 = 'python666'
    test3 = 'python'
    test4 = '666'
    test5 = '---'
    
    print(test1.isdigit())		# False
    print(test2.isdigit())		# False
    print(test3.isdigit())		# False
    print(test4.isdigit())		# True
    print(test5.isdigit())		# False

### islower() ###

**检测字符串是否由小写字母组成。**

> str.islower()

test1 = 'i love python6'
    test2 = 'i love python-'
    test3 = 'i love python'
    test4 = 'I LOVE PYTHON'
    test5 = 'i LOVE python'
    
    print(test1.islower())		# True
    print(test2.islower())		# True
    print(test3.islower())		# True
    print(test4.islower())		# False
    print(test5.islower())		# False

--------------------

### encode()与decode() ###

encode函数以 encoding指定的编码格式编码字符串而decode函数则是与encode函数相反。errors参数可以指定不同的错误处理方案。encode函数返回编码后的bytes类型对象，decode函数则是返回解码后的字符串。

> str.encode(\[encoding\]\[,errors\])  
> bytes.decode(\[encoding\]\[,errors\])

*  encoding – 要使用的编码，默认为"UTF-8"。
 *  errors – 设置不同错误的处理方案。默认为 ‘strict’。其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register\_error() 注册的任何值。

msg = '你好'
    
    res = msg.encode()				# 默认为utf-8
    res2 = msg.encode('utf-8')
    print(type(res2))				# <class 'bytes'>
    print(res == res2)				# True
    print(res.decode())				# # 默认为utf-8

--------------------

### join() ###

用于**将序列中的元素以指定的字符连接生成一个新的字符串。**

> str.join(sequence)

*  equence – 要连接的元素序列。

str1 = '-'
    
    seq = ("a", "b", "c")
    print(str1.join(seq))		# a-b-c

### split() ###

**通过指定分隔符对字符串进行切片**，如果参数 num 有指定值，则分隔成 num+1 个子字符串

> str.split(str, num)

*  str – 分隔符，默认为所有的空字符，包括空格、换行(\\n)、制表符(\\t)等。
 *  num – 分割次数。默认为 -1, 即分隔所有。

str1 = "Line1-abcdef \nLine2-abc \nLine4-abcd"
    str2 = "Line1-abcdef\nLine2-abc\nLine4-abcd"
    str3 = "Line1-abcdef\tLine2-abc\tLine4-abcd"
    str4 = "Line1-abcdef Line2-abc Line4-abcd"
    
    print(str1.split())		# ['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
    print(str2.split())		#['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
    print(str3.split())		#['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
    print(str4.split())		#['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
    print(str1.split(' ', 1))		#['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

### count() ###

**用于统计字符串里某个字符出现的次数**。可选参数为在字符串搜索的开始与结束位置。

> str.count(sub, start,end)

*  sub – 搜索的子字符串
 *  start – 字符串开始搜索的位置。默认第一个字符索引值为0。
 *  end – 字符串中结束搜索的位置。默认为字符串的长度。

test1 = '88888i lov888e pyth8on88888'		# 27个字符，14个8
    
    print(test1.count('8', 0, 27))			# 14
    print(test1.count('8', 1, 27))			# 13
    print(test1.count('8', 0, 26))			# 13
    print(test1.count('8', 1, 26))			# 12

### 切片 ###

str1 = 'hello world'
    
    print(str1[1:7])		# ello w
    print(str1[1::2])		# el ol
    print(str1[::-1])		# 倒序，dlrow olleh

# 三、列表 #

**列表**内数据可以**增删查改**；当**列表内数据改变**时，其**内存地址不会改变**；列表内的数据可以是**任何的数据类型**；并且它也**支持索引和切片**

### 切片 ###

li = ['abcd', 123, True, 12.3]
    
    print(li)				# ['abcd', 123, True, 12.3]
    print(li[0])			# abcd
    print(li[-1])			# 12.3
    print(li[1:2])			# [123]，切片
    print(li * 2)			# ['abcd', 123, True, 12.3, 'abcd', 123, True, 12.3]，列表的复制

### append() ###

**用于在列表末尾添加新的对象。**

> list.append(obj)

li = ['abcd', 123, True, 12.3]
    
    print(li)			# ['abcd', 123, True, 12.3]
    li.append([1, 2])
    print(li)			# ['abcd', 123, True, 12.3, [1, 2]]

### insert() ###

**用于将指定对象插入列表的指定位置。**

> list.insert(index, obj)

*  index – 对象 obj 需要插入的索引位置。
 *  obj – 要插入列表中的对象。

aList = [123, 'xyz', 'zara', 'abc', 123]
    aList.insert(1, 123)
    print(aList)			# [123, 123, 'xyz', 'zara', 'abc', 123]

### extend() ###

**用于在列表末尾一次性追加另一个序列中的多个值**（用新列表扩展原来的列表）。

> list.extend(seq)

*  seq – 元素列表。

aList = [123, 'xyz', 'zara', 'abc', 123]
    bList = [2009, 'manni']
    
    aList.extend(bList)
    print(aList)			# [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

--------------------

### count() ###

**用于统计某个元素在列表中出现的次数。**

> list.count(obj)

aList = [123, 'xyz', 'zara', 'abc', 123]
    
    print(aList.count(123))			# 2
    print(aList.count('zara'))		# 1

### index() ###

**用于从列表中找出某个值第一个匹配项的索引位置，当找不到的时候会报错。**

> list.index(x\[, start\[, end\]\])

*  x-- 查找的对象。
 *  start-- 可选，查找的起始位置。
 *  end-- 可选，查找的结束位置。

aList = [123, 'xyz', 'zara', 'abc', 123]
    
    print(aList.index(123))			# 0
    print(aList.index(777))			# 当找不到的时候会报错

注意**列表没有rindex方法**，只要**字符串才有‘r’方法**

--------------------

### pop() ###

**用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。**

> list.pop(\[index\])

*  index-- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

aList = [123, 'xyz', 'zara', 'abc', 123]
    
    aList.pop()
    print(aList)			# [123, 'xyz', 'zara', 'abc']
    aList.pop(0)
    print(aList)			# ['xyz', 'zara', 'abc']

### remove() ###

**用于移除列表中某个值的第一个匹配项，没有找到的话就报出错误。**

> list.remove(obj)

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    
    aList.remove('xyz')
    print(aList)			# [123, 'zara', 'abc', 'xyz']

### clear() ###

**用于删除列表中所有值。**

> list.clear()

li = ['abcd', 123, True, 12.3]
    
    li.clear()				# []

### del ###

**删除列表内的某项**

listA = list(range(10, 20))
    
    print(listA)				# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    del listA[0]	
    print(listA)				# [11, 12, 13, 14, 15, 16, 17, 18, 19]
    del listA[1:4]
    print(listA)				# [11, 15, 16, 17, 18, 19]

--------------------

### sort() ###

**用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。**

> list.sort( key=None, reverse=False)

*  key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 *  reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
    
    aList.sort()
    print("List : ", aList)				# List : ['Facebook', 'Google', 'Runoob', 'Taobao']

### reverse() ###

**用于反向列表中元素。**

> list.reverse()

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    
    aList.reverse()
    print(aList)			# ['xyz', 'abc', 'zara', 'xyz', 123]

# 四、元组 #

**元组于列表类似**，不同之处在于**元组的一级元素不能增、删、改**；它也**可以进行索引和切片**；元组内可以是任何类型；**当元组中只有一个元素时，要加上逗号，不然解释器会当做整形来处理**

tupleA = ('abcd', 89, 12.3, 'peter', [11, 22], 'peter')
    
    print(tupleA.count('peter'))		# 2，用来计算'peter'在元组内出现的次数
    
    print(tupleA[0])			# abcd
    print(tupleA[1:3])			# (89, 12.3)
    print(tupleA[-1:-3:-1])		# ('peter', [11, 22])
    print(tupleA[-2:-1:])		# ([11, 22],)，注意当元组内只有一个元素时有逗号的
    
    tupleA[4][0] = 22
    print(tupleA)				# ('abcd', 89, 12.3, 'peter', [22, 22], 'peter')，不可以修改元组的值，但可以修改元组值得值
    
    tupleB = (1)
    print(type(tupleB))			# <class 'int'>
    
    tupleC = (1,)
    print(type(tupleC))			# <class 'tuple'>
    
    tupleA[0] = 1				# 元组不能修改，在这里会爆出error
    print(tupleA)

### count() ###

**用于统计某个元素在元组中出现的次数。**

> list.count(obj)

name = (0, 1, 2, 3, 4, 5, 0)
    
    print(name.count(1))		# 1
    print(name.count(7))		# 0

### index() ###

**用于从元组中找出某个值第一个匹配项的索引位置，当找不到的时候会报错。**

> list.index(x\[, start\[, end\]\])

*  x-- 查找的对象。
 *  start-- 可选，查找的起始位置。
 *  end-- 可选，查找的结束位置。

name = (0, 1, 2, 3, 4, 5, 0)
    
    print(name.index(0))				# 0
    print(name.index(0, 1))				# 6
    print(name.index(0, 1, 6))			# 当找不到的时候会报错

### 拆包和装包 ###

**装包**就是**把未命名的参数放到元组**中，把**命名参数放到字典**中，**拆包**将一个**结构**中的数据拆**分为多个单独变量**  
[参考案例][Link 1]

# 五、字典 #

字典是以键值对的形式存在的 ，**字典不可使用索引和切片，它支持添加、修改、删除**

dictA = dict([('name', 'ming'), ('age', 20)])		# 列表
    dictB = dict((('name', 'ming'), ('age', 21)))		# 元组
    print(dictA)					# {'name': 'ming', 'age': 20}
    print(dictB)					# {'name': 'ming', 'age': 21}
    
    dictA = { 'name': '李华'}
    dictA['age'] = 30				# 添加值
    
    print(len(dictA))				# 获得字典长度
    print(dictA['age'])
    
    dictA['age'] = 40				# 修改值
    print(dictA['age'])
    
    print(dictA.keys())
    print(dictA.values())
    print(dictA.items())
    
    dictA.update({ 'name': '李明'})
    print(dictA)
    
    for (key, value) in dictA.items():
        print('{}为{}'.format(key, value))
        pass

### keys() ###

**获得字典的所有键**

dictA = { 'name': '李华', 'age': 40}
    
    print(dictA.keys())			# 结果为dict_keys(['name', 'age'])
    for value in dictA.keys():
        print(value)
        pass

## values() ##

**获得字典的所有键值**

dictA = { 'name': '李华', 'age': 40}
    
    print(dictA.values())			# 结果为dict_values(['李华', 40])
    for value in dictA.values():
        print(value)
        pass

### items() ###

**获得字典的所有键对，结果里面的item为tuple类型**

dictA = { 'name': '李华', 'age': 40}
    
    print(dictA.items())			# 结果为dict_items([('name', '李华'), ('age', 40)])
    for (key, value) in dictA.items():	# key为键，value为键值
        print('{}为{}'.format(key, value))
        pass

### update() ###

**若更新的内容在字典内有则更改，若没有则添加**

dictA = { 'name': '李华', 'age': 40}
    
    dictA.update({ 'name': '李明'})		# 修改
    dictA.update({ 'class': 1})			# 添加
    
    print(dictA)

### del、pop()与clear() ###

**删除操作**，**pop() 方法**删除字典给**定键 key及对应的值，返回值为被删除的值**，若**没有找值到则返回 default 值**，字典**没有remove方法**

> pop(key\[,default\])

dictA = { 'name': '李华', 'age': 40}
    
    del dictA['name']			# 删除
    dictA.pop('age')
    print(dictA)
    
    dictA.clear()				# 清空字典
    print(dictA)				# {}

### get() ###

函数返回**指定键的值**

> dict.get(key, default=None)

*  **key** – 字典中要查找的键。
 *  **default** – 如果指定键的值不存在时，返回该默认值。

dictA = { 'name': '李华', 'age': 40}
    
    print(dictA.get('gender', 'male'))			# male
    print(dictA.get('age', 0))					# 40
    print(dictA)					# {'name': '李华', 'age': 40}

# 六、集合操作 #

**set（集合）也是python里面的一种数据类型**，是一**无序**且**不重复**的**元素集合**，它**不支持索引与切片**

> **add()** – 添加值，不能为重复的值  
> **clear()** – 清空set  
> **difference()** – 取差集， -也可以；而 **difference\_update()** 为取差集并赋值  
> **intersection()** – 取交集，&也可以；而 **intersection\_update()** 为取交集并赋值  
> **union()** – 取并集，|也可以  
> **symmetric\_difference()** – 取对称差集，^也可以；而 **symmetric\_difference\_update()** 为取对称差集并赋值  
> **pop()** – 从集合中随机移除某个元素并获取那个参数，集合pop没有参数，建议使用**discard()**  
> **discard()** – 移除指定元素  
> **remove()** – 集合中删除指定的元素。此方法与 discard() 不同，因为如果指定项目不存在，remove() 会引发错误，而 discard() 不会。  
> **update()** – 更新集合，用于把两个集合合并，并去重

set1 = { 1, '2'}          	# 集合的创建
    set2 = { }					# 这样不能创建集合
    set3 = set()				# 集合的创建
    list1 = [1, 2, 3]
    set4 = set(list1)			# 使用set方法创建集合
    
    print(type(set1))			# <class 'set'>
    print(type(set2))			# <class 'set'>
    print(type(set3))			# <class 'set'>
    print(type(set4))			# <class 'set'>
    
    set1.add((5, 6))			# 添加一个值
    print(set1)					# {1, (5, 6), '2'}
    set1.update((5, 6))			# 把元组拆开再添加值
    print(set1)					# {1, 5, 6, (5, 6), '2'}
    
    print(set1.difference(set4))	# 差集，{'2', (5, 6), 5, 6}
    print(set1.union(set4))			# 并集，{1, 2, 3, 5, 6, (5, 6), '2'}
    print(set1.intersection(set4))	# 交集，{1}
    print(set1.symmetric_difference(set4))		# {2, 3, 5, 6, (5, 6), '2'}
    
    set1.pop()					# 随机删除一个值
    print(set1)					# {5, 6, (5, 6), '2'}
    set1.discard('2')			# 在集合里面删除对应值
    print(set1)					# {5, 6, (5, 6)}
    set1.remove(5)				# 在集合里面移除值为5的值
    print(set1)					# {5, 6, (5, 6)}
    set1.remove(7)				# 在集合里面移除值为7的值
    # print(set1) # 因为值不存在，所以报错
    
    set4.clear()				# 删除集合里面所有值
    print(set4)					# set()

# 七、公用方法 #

### sorted() ###

**对所有可迭代的对象进行排序操作。**

> sorted(iterable, cmp=None, key=None, reverse=False)

*  iterable – 可迭代对象。
 *  cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
 *  key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 *  reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

**注意**：**Python list内置sort()方法**用来排序，也可以用**python内置的全局sorted()方法**来对可迭代的序列排序生成新的序列。**list 的 sort 方法**是对**已经存在的列表**进行操作，**无返回值**，而**内建函数 sorted 方法**返回的是**一个新的 list**，而**不是在原来的基础上进行的操作。**

dictA = { 'name': '李华', 'age': 40}
    
    print(sorted(dictA.items(), key=lambda d: d[0]))	# 排序

### \+合并操作 ###

适用于**字符串，列表，元组**

strA = '123'
    strB = '456'
    listA = list(range(10))
    listB = list(range(11, 21))
    tupleA = (1,)
    tupleB = (2, 3, 4)
    dictA = { 'name': '李明'}
    dictB = { 'age': 30}
    
    print(strA + strB)		# 123456
    print(listA + listB)		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
    print(tupleA + tupleB)		# (1, 2, 3, 4)
    print(dictA + dictB)		# 报错，字典不可使用+

### \*复制 ###

适用于**字符串，列表，元组**

strA = '123'
    listA = list(range(10))
    tupleA = (1,)
    dictA = { 'name': '李明'}
    
    print(strA * 3)		# 123123123
    print(listA * 3)		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(tupleA * 3) 	# (1, 1, 1)
    print(dictA * 3)	# 报错，字典不可使用*

### in判断元素是否存在 ###

适用于**字符串，列表，元组，字典**；而**not in则于它相反**

strA = '123'
    listA = list(range(10))
    tupleA = (1,)
    dictA = { 'name': '李明'}
    
    print('1' in strA)			# True
    print('0' in strA)			# False
    print(1 in listA)			# True
    print(-1 in listA)			# False
    print(1 in tupleA)			# True
    print(0 in dictA)			# False
    print('name' in dictA)			# True
    print('age' in dictA)			# False

# 八、其他 #

### id( ) ###

**用于查找在内存的物理地址**

str1 = 'hello'
    str2 = str1
    
    print(id(str1))			# 1970902101296
    print(id(str2))			# 1970902101296

# 九、可变与不可变类型 #

### 可变类型 ###

**可变类型**为对象**引用指向**的**值为可变**的，这就意味着**当对象重新赋值时对象的引用不会改变**，可变的类型有**列表、字典**

import ctypes				# 该库用于查找内存地址对应的值
    
    value = [1, 2]				# 定义一个列表
    value1_loc = id(value)		# 获得当前列表的内存地址
    print(value1_loc)			# 输出地址，2075718505536
    
    value[0] = 3  				# 列表里面的值重新赋值
    value2_loc = id(value)		# 获得当前列表的内存地址
    print(value2_loc)			# 输出地址，2075718505536
    get_value = ctypes.cast(value1_loc, ctypes.py_object).value  # 读取对应地址的值
    print(get_value)			# 输出对应地址的值，[3, 2]

### 不可变类型 ###

**不可变类型**为对象**引用指向的值为不可变**的，这就意味着**当对象重新赋值时对象的引用也改变了值**，而**原来的值还在内存池里**面，不可变的类型有**int、str、float、元组**，下面就可以说明这个问题

import ctypes			# 该库用于查找内存地址对应的值
    
    value = 'hello world'	# 定义一个字符串变量
    value1_loc = id(value)	# 获得当前变量的内存地址
    print(value1_loc)		# 输出地址，1475453744688
    
    value = '你好'			# 字符串变量重新赋值
    value2_loc = id(value)	# 获得当前变量的内存地址
    print(value2_loc)		# 输出地址，1475458315248
    get_value = ctypes.cast(value1_loc, ctypes.py_object).value  # 读取对应地址的值
    print(get_value)		# 输出对应地址的值，hello world

本文只用于个人学习与记录

[Link 1]: https://blog.csdn.net/weixin_37963567/article/details/105786327