#在python3中并不会
number = 123
print(type(number))
number2 = 2147483647
print(type(number2))
number2 = 2147483648 #我们会看到超过2147483647这个范围，在py2中整形就会变成长整形了
print(type(number2))
# 常用的method的如下：.bit_length()
number = 12 #1100
print(number.bit_length())
# 浮点型可以看成就是小数，type为float
#浮点型
number = 1.1
print(type(number))
# 常用method的如下：
# .as_integer_ratio()
print((10.0).as_integer_ratio())
print((-.25).as_integer_ratio())
number = 0.25
print(number.as_integer_ratio())
print((-0.1).hex())
print(3.14159.hex())
number = 3.1415
print(number.hex())
# .fromhex（）
# 将十六进制小数以字符串输入，返回十进制小数
print(float.fromhex('0x1.ffffp10'))
print(float.fromhex('-0x1p-1074'))
print(float.fromhex('0x1.921cac083126fp+1'))
# .is_integer()
# 判断小数是不是整数，比如3.0为一个整数，而3.1不是，返回布尔值
number = 3.1415
number2 = 3.0
print(number.is_integer())
print(number2.is_integer())
# 字符串就是一些列的字符，在Python中用单引号或者双引号括起来，多行可以用三引号
name = 'my name is Frank'
name1 = "my name is Frank"
name2 = '''
my name is Frank
I'm 23 years old,
'''
print(name)
print(name1)
print(name2)
# 常用method的如下：
# .capitalize()
# 字符串首字符大写
name = 'my name is Frank'
print(name.capitalize())
# .center()
# 字符居中，指定宽度和填充字符（默认为空格）
flag = "Welcome Frank"
print(flag.center(50, '*'))
# .count()
# 计算字符串中某个字符的个数，可以指定索引范围
flag = 'aaababbcccaddadaddd'
print(flag.count('a'))
print(flag.count('a', 0, 5))# 数字符串前0到n个
# .encode()
# 编码，在python3中，str默认是unicode数据类型，可以将其编码成bytes数据
flag = 'aaababbcccaddadaddd'
print(flag.encode('utf8'))
# .endswith()
# 判断字符串结尾是否是某个字符串和字符，可以通过索引指定范围
flag = 'aaababbcccaddadaddd'
print(flag.endswith('aa'))
print(flag.endswith('ddd'))
print(flag.endswith('dddd'))
print(flag.endswith('aaa', 0, 3))
print(flag.endswith('aaa', 0, 2))
# .expandtabs()
# 把制表符tab("\t")转换为空格
flag = "\thello python!"
print(flag)
print(flag.expandtabs()) #默认tabsize=8
print(flag.expandtabs(20))
# .find()
# 查找字符，返回索引值，可以通过指定索引范围内查找，查找不到返回-1
flag = "hello python!"
print(flag.find('e'))
print(flag.find('a'))
print(flag.find('h', 4, -1))
# .format()
# 格式化输出，使用"{}"符号作为操作符
# 位置参数
flag = "hello {0} and {1}!"
print(flag.format('python', 'php'))
flag = "hello {} and {}!"
print(flag.format('python', 'php'))
# 变量参数
flag = "{name} is {age} years old!"
print(flag.format(name='Frank', age = 23))
# 结合列表
infor=["Frank", 23]
print("{0[0]} is {0[1]} years old".format(infor))
# .format_map()
# 格式化输出
people={
'name': ['Frank', 'Caroline'],
'age': ['23', '22'],
}
print("My name is {name[0]},i am {age[1]} years old !".format_map(people))
# .index()
# 根据字符查找索引值，可以指定索引范围查找，查找不到会报错
flag = "hello python!"
print(flag.index("e"))
print(flag.index("o", 6, -1))
# .isalnum()
# 判断是否是字母或数字组合，返回布尔值
flag = "hellopython"
flag1 = "hellopython22"
flag2 = "hellopython!!"
flag3 = "!@#!#@!!@"
print(flag.isalnum())
print(flag1.isalnum())
print(flag2.isalnum())
print(flag3.isalnum())
# .isalpha()
# 判断是否是字母组合，返回布尔值
flag = "hellopython"
flag1 = "hellopython22"
print(flag.isalpha())
print(flag1.isalpha())
# .isdecimal()
# 判断是否是一个十进制正整数，返回布尔值
number = "1.2"
number1 = "12"
number2 = "-12"
number3 = "1222"
print(number.isdecimal())
print(number1.isdecimal())
print(number2.isdecimal())
print(number3.isdecimal())
# isdigit()
# 判断是否是一个正整数，返回布尔值，与上面isdecimal类似
number = "1.2"
number1 = "12"
number2 = "-12"
number3 = "11"
print(number.isdigit())
print(number1.isdigit())
print(number2.isdigit())
print(number3.isdigit())
print(".isidentifier()")
print("判断是否为python中的标识符")
flag = "cisco"
flag1 = "1cisco"
flag2 = "print"
print(flag.isidentifier())
print(flag1.isidentifier())
print(flag2.isidentifier())
print(".islower()")
print(" 判断字符串中的字母是不是都是小写，返回布尔值")
flag = "cisco"
flag1 = "cisco222"
flag2 = "Cisco"
print(flag.islower())
print(flag1.islower())
print(flag2.islower())
print(".isnumeric()判断是否为数字，这个很强大，中文字符，繁体字数字都可以识别")
number = "123"
number1 = "一"
number2 = "壹"
number3 = "123q"
number4 = "1.1"
print(number.isnumeric())
print(number1.isnumeric())
print(number2.isnumeric())
print(number3.isnumeric())
print(number4.isnumeric())
print(".isprintable() 判断引号里面的是否都是可打印的，返回布尔值")
flag = "\n123"
flag1 = "\t"
flag2 = "123"
flag3 = r"\n123" # r 可以让转义字符失效
print(flag.isprintable()) # \n不可打印
print(flag1.isprintable()) # \t不可打印
print(flag2.isprintable())
print(flag3.isprintable())
print(".isspace()判断字符串里面都是空白位，空格或者tab，返回布尔值")
flag = ' ' #4个空格
flag1 = ' '#2个tab
print(flag.isspace())
print(flag1.isspace())
print(".istitle()判断字符串里面的字符是否都是大写开头，返回布尔值")
flag = "Welcome Frank"
flag1 = "Welcome frank"
print(flag.istitle())
print(flag1.istitle())
print(".isupper()判断是否都是字符串里的字母都是大写")
flag = "WELCOME1"
flag1 = "Welcome1"
print(flag.isupper())
print(flag1.isupper())
print(".join()将字符串以指定的字符连接生成一个新的字符串")
flag = "welcome"
print("#".join(flag))
print(".ljust()左对齐，可指定字符宽度和填充字符")
flag = "welcome"
print(flag.ljust(20, "*"))
print(".rjust()右对齐，可指定字符宽度和填充字符")
flag = "welcome"
print(flag.rjust(20, "*"))
print("lower()对字符串里的所有字母转小写")
flag = "WELcome"
print(flag.lower())
print(".upper()对字符串里的所有字母转大写")
flag = "WELcome"
print(flag.upper())
print(".title()对字符串里的单词进行首字母大写转换")
flag = "welcome frank"
print(flag.title())
print(".lstrip()默认去除左边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位 ")
flag = " welcome frank"
flag1 = "@@@@welcome frank"
print(flag.lstrip())
print(flag.lstrip("@"))
print(flag.lstrip("@").lstrip())
print(".rstrip()默认去除右边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位")
flag = "welcome frank "
flag1 = "welcome frank@@@@"
# print(flag.title())
print(flag.rstrip())
print(flag.rstrip("@"))
print(flag.rstrip("@").rstrip())
print(".strip()默认去除两边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位")
flag = " welcome frank "
flag1 = "@@@@welcome frank@@@@"
# print(flag.title())
print(flag.strip())
print(flag.strip("@"))
print(flag.strip("@").strip())
print(".maketrans()和translate()")
# 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
# 第一个参数是字符串，表示需要转换的字符，
# 第二个参数也是字符串表示转换的目标。
# 两个字符串的长度必须相同，为一一对应的关系。
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print(str.translate(trantab))
print(".partition()")
print("以指定字符分割，返回一个元组")
flag = "welcome"
print(flag.partition("e"))
print(".replace(）将指定的字符替换为新的字符，可指定替换的个数")
flag = "welcome frank ,e.."
print(flag.replace("e", "z"))
print(flag.replace("e", "z", 1))
print(".rfind()返回字符串第一次出现的位置，从右向左算，返回索引值，若没有，则返回-1，可根据索引范围查找")
flag = "welcome frank ,e.."
print(flag.rfind("e"))
print(flag.rfind("x"))
print(flag.rfind("e",0,3))# 从右边往左边数
print(".rindex()查找字符索引值，从右向左，返回索引值，与rfind类似，查找不到会报错")
flag = "welcome frank ,e.."
print(flag.rindex("e"))
print(flag.rindex("e", 0, 3))
print(".rpartition()")
print("以指定字符从右向左分割，只分割一次，返回元组，若没有指定的字符，则在返回的元组前面加两个空字符串")
flag = "welcome frank ,e.."
print(flag.rpartition("e"))
print(flag.rpartition("x"))
print(".split()")
print('''
分割，可以以指定的字符分割，可指定分割的次数，默认从左向右分割，
与partition不同的是，split分割后会删除指定的字符，
默认以空格为分割符，返回元组。
''')
flag = "welcome frank, e.."
print(flag.split())
print(flag.split('e'))
print(flag.split('e',1))
print(".rsplit()")
print("与split类似，只是它是从右向左分")
flag = "welcome frank, e.."
print(flag.rsplit())
print(flag.rsplit('e'))
print(flag.rsplit('e',1))
print(".splitlines()")
print("判断是否以指定字符串或字符开头，可指定索引范围，返回布尔值")
info = "hello,my name is Frank"
print(info.startswith("he"))
print(info.startswith("e"))
print(info.startswith("m", 6, -1))
print(".swapcase()")
print("将字符串中的大小写互换")
info = "Hello,My name is Frank"
print(info.swapcase())
print(".zfill（）")
print("指定字符串宽度，不足的右边填“0”")
info = "Hello,My name is Frank"
print(info.zfill(50))
name = ['Frank', 'Caroline', 'Bob', 'Saber']
# 直接打印会将中括号、引号和逗号都打印出来
print(name)
# 添加索引可打印对应的值，从索引值从0开始
print(name[1])
# 打印最后一个元素
print(name[-1])
# 用冒号来切片,取左不包含2
print(name[0:2])
# 冒号右边不写代表一直打印到最后一个
print(name[-2:])
# 冒号左边不写代表从第“0”个开始打印
print(name[:1])
print(".index()")
print("查找对应元素的索引值，返回索引值，可以指定索引范围来查找，查找不到会报错")
name = ['Frank','Caroline','Bob','Saber']
print(name.index("Frank"))
print(name.index("Bob", 1, -1))
print(".count(）")
print("计算某个元素的个数")
name = ['Frank', 'Caroline', 'Bob', 'Saber', 'Frank']
print(name.count('Frank'))
print(" .append()")
name = ['Frank', 'Caroline', 'Bob', 'Saber', 'Frank']
name.append('Mei')
print(name)
print(".clear()清空列表")
name = ['Frank','Caroline','Bob','Saber','Frank']
name.clear()
print(name)
#####################################################################################
C:\Anaconda3\python.exe H:/python/venv/text
<class 'int'>
<class 'int'>
<class 'int'>
4
<class 'float'>
(10, 1)
(-1, 4)
(1, 4)
-0x1.999999999999ap-4
0x1.921f9f01b866ep+1
0x1.921cac083126fp+1
2047.984375
-5e-324
3.1415
False
True
my name is Frank
my name is Frank
my name is Frank
I'm 23 years old,
My name is frank
******************Welcome Frank*******************
7
4
b'aaababbcccaddadaddd'
False
True
False
True
False
hello python!
hello python!
hello python!
1
-1
9
hello python and php!
hello python and php!
Frank is 23 years old!
Frank is 23 years old
My name is Frank,i am 22 years old !
1
10
True
True
False
False
True
False
False
True
False
True
False
True
False
True
.isidentifier()
判断是否为python中的标识符
True
False
True
.islower()
判断字符串中的字母是不是都是小写，返回布尔值
True
True
False
.isnumeric()判断是否为数字，这个很强大，中文字符，繁体字数字都可以识别
True
True
True
False
False
.isprintable() 判断引号里面的是否都是可打印的，返回布尔值
False
False
True
True
.isspace()判断字符串里面都是空白位，空格或者tab，返回布尔值
True
True
.istitle()判断字符串里面的字符是否都是大写开头，返回布尔值
True
False
.isupper()判断是否都是字符串里的字母都是大写
True
False
.join()将字符串以指定的字符连接生成一个新的字符串
w#e#l#c#o#m#e
.ljust()左对齐，可指定字符宽度和填充字符
welcome*************
.rjust()右对齐，可指定字符宽度和填充字符
*************welcome
lower()对字符串里的所有字母转小写
welcome
.upper()对字符串里的所有字母转大写
WELCOME
.title()对字符串里的单词进行首字母大写转换
Welcome Frank
.lstrip()默认去除左边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位
welcome frank
welcome frank
welcome frank
.rstrip()默认去除右边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位
welcome frank
welcome frank
welcome frank
.strip()默认去除两边空白字符，可指定去除的字符，去除指定的字符后，会被空白占位
welcome frank
welcome frank
welcome frank
.maketrans()和translate()
th3s 3s str3ng 2x1mpl2....w4w!!!
.partition()
以指定字符分割，返回一个元组
('w', 'e', 'lcome')
.replace(）将指定的字符替换为新的字符，可指定替换的个数
wzlcomz frank ,z..
wzlcome frank ,e..
.rfind()返回字符串第一次出现的位置，从右向左算，返回索引值，若没有，则返回-1，可根据索引范围查找
15
-1
1
.rindex()查找字符索引值，从右向左，返回索引值，与rfind类似，查找不到会报错
15
1
.rpartition()
以指定字符从右向左分割，只分割一次，返回元组，若没有指定的字符，则在返回的元组前面加两个空字符串
('welcome frank ,', 'e', '..')
('', '', 'welcome frank ,e..')
.split()
分割，可以以指定的字符分割，可指定分割的次数，默认从左向右分割，
与partition不同的是，split分割后会删除指定的字符，
默认以空格为分割符，返回元组。
['welcome', 'frank,', 'e..']
['w', 'lcom', ' frank, ', '..']
['w', 'lcome frank, e..']
.rsplit()
与split类似，只是它是从右向左分
['welcome', 'frank,', 'e..']
['w', 'lcom', ' frank, ', '..']
['welcome frank, ', '..']
.splitlines()
判断是否以指定字符串或字符开头，可指定索引范围，返回布尔值
True
False
True
.swapcase()
将字符串中的大小写互换
hELLO,mY NAME IS fRANK
.zfill（）
指定字符串宽度，不足的右边填“0”
0000000000000000000000000000Hello,My name is Frank
['Frank', 'Caroline', 'Bob', 'Saber']
Caroline
Saber
['Frank', 'Caroline']
['Bob', 'Saber']
['Frank']
.index()
查找对应元素的索引值，返回索引值，可以指定索引范围来查找，查找不到会报错
0
2
.count(）
计算某个元素的个数
2
.append()
['Frank', 'Caroline', 'Bob', 'Saber', 'Frank', 'Mei']
.clear()清空列表
[]
Process finished with exit code 0
#########################################################################################
print(".copy()复制列表")
name = ['Saber', 'Frank', 1, 2, [3,4]]
name_cp = name.copy()
print(name_cp)
name[0]='Tom'
name[3]='7'
name[4][0]='8'
print(name)
print(name_cp)
########################################################################
C:\Anaconda3\python.exe H:/python/venv/text
.copy()复制列表
['Saber', 'Frank', 1, 2, [3, 4]]
['Tom', 'Frank', 1, '7', ['8', 4]]
['Saber', 'Frank', 1, 2, ['8', 4]]
Process finished with exit code 0
我们会发现，我们给name[0]、name[3]、和name[4][0]都重新赋值了，为什么我重新赋值的name[4][0]会影响到我复制的列表的呢？
首先我们来看一下这个复制图解：
我们在复制的时候，新复制的列表都会指向被复制列表的地址空间，name[4]和name_cp[4]本身也是个列表，它们指向的是同一个列表地址空间。我们来看一下给name列表重新赋值后，地址空间的变化：
重新赋值后，内存给name[3]、name[0]、name[4][0]都重新开辟了一块内存空间，name[0]指向了内存地址38703432，name[3]指向了内存地址1400943960，而name[4]还是指向37092936,但是内存地址37092936指向name[4][0]内存地址发生了变化，指向了1400944350，所以，在列表中的列表我们给它重新赋值的时候，也会改变复制列表的值，因为它们的列表里的列表都是指向同一块地址空间。那么如果我们想完全复制怎么办呢？
# 可以调用函数deepcopy().
import copy
name = ['Saber', 'Frank', 1, 2, [3, 4]]
name_cp = copy.deepcopy(name)
name[4][0] = 5
print(name)
print(name_cp)
########################################################
C:\Anaconda3\python.exe H:/python/venv/text
['Saber', 'Frank', 1, 2, [5, 4]]
['Saber', 'Frank', 1, 2, [3, 4]]
Process finished with exit code 0
这样会给复制后的列表中的列表重新开辟一个地址空间，然后指向列表中列表的元素的地址空间，这样你怎么改变原列表name，name_copy都不会改变。
# 可以调用函数deepcopy().
# 深拷贝 就是针对复制地址一份，所以不会随之改变
import copy
name = ['Saber', 'Frank', 1, 2, [3, 4]]
name_cp = copy.deepcopy(name)
print(name_cp)
name[0]='Tom'
name[3]='7'
name[4][0] = 5
print(name)
print(name_cp)
# 浅拷贝 两个指向同一个地址，一个改变一个随之改变
print(".copy")
name = ['Saber', 'Frank', 1, 2, [3, 4]]
name_cp = name.copy()
print(name_cp)
name[0]='Tom'
name[3]='7'
name[4][0]='8'
print(name)
print(name_cp)print(".extend()")
print("函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）")
name = ['Saber', 'Frank']
nameto = ['Mei', 'Jack']
name.extend(nameto)
print(name)
print("insert()")
print("插入元素，需要指定索引值来插入")
name = ['Saber', 'Frank']
name.insert(0, 'Jack')
print(name)
print(" .pop()")
print("弹出元素，默认弹出最后一个元素，可以指定索引，弹出对应的元素，当列表弹空或者没有指定的索引值会报错，并返回弹出的值")
name = ['Saber', 'Frank', 'Caroline', 'Jack']
name.pop() # 弹出元素，默认弹出最后一个元素
print(name)
name = ['Saber', 'Frank', 'Caroline', 'Jack']
name.pop(1)
print(name)
print(".remove()移除指定的元素")
name = ['Saber', 'Frank', 'Caroline', 'Jack']
name.remove('Frank')
print(name)
print(".reverse()列表反转，永久修改")
name = ['Saber', 'Frank', 'Caroline', 'Jack']
name.reverse()
print(name)
print(".sort()对列表进行排序，永久修改，如果列表中同时存在不同类型的数据，则不能排序，比如含有整型和字符串，传递reverse=True可以倒着排序。")
name = ['Saber', 'Frank', 'Caroline', 'Jack', '1', 'abc', 'xyz']
name.sort() # 如果列表中同时存在不同类型的数据，则不能排序，
print(name)
name.sort(reverse=True)
print(name)
number = [1, 2, 3, 42, 12, 32, 43, 543]
number.sort()
print(number)
number.sort(reverse=True)
print(number)
print("五、元组")
# 元组和列表类似，不同的是元组的元素是不能修改的，使用小括号"()"括起来，用逗号","分开，其type为tuple
print(".count()")
number = (1,2,2,2,1)
print(number.count(2))
print(".index(）")
print("查找指定元素的索引，可以指定索引范围来查找")
number = (1,2,2,2,1)
print(number.index(2))
print(number.index(2, 2, -1))
print("六、集合")
# 集合是一系列无序的元素组成，所有你不能使用索引值，在打印的时候，元组是自然排序，天然去重的，其type为set 从小到大
number = {1,2,3,4,4,5,6}
number1 = {1,6,2,1,8,9,10}
print(number)
print(number1)
print(".remove()")
print("移除指定的元素")
number = {1,2,3,4,4,5,6}
print(number)
number.remove(1)
print(number)
print(".pop()弹出排序过后的第一个元素")
number = {1,2,3,4,4,5,6}
print(number)
number_pop = number.pop()
print(number_pop)
print(number)
print(".clear()清空列表返回set()")
number = {1,2,3,4,4,5,6}
print(number)
number.clear()
print(number)
print(".copy()复制集合")
number = {1,2,3,4,4,5,6}
print(number)
number2 = number.copy()
number.pop() # 对复制的集合没有任何影响
print(number)
print(number2)
print(".add()")
number = {1,2,3,4,4,5,6}
print(number)
number.add(7)
print(number)
print(".difference()求差集 可以用-代替")
number = {1, 2, 3, 4, 5, 6, 8, 9}
number1 = {2, 3, 8, 9, 11, 12, 10}
print(number.difference(number1))
print(number1.difference(number))
print(number - number1)
print(number1 - number)
print(".union()求并集 可以用|代替")
number = {1, 2, 3, 4, 5, 6, 8, 9}
number1 = {2, 3, 8, 9, 11, 12, 10}
print(number.union(number1))
print(number | number1)
print("difference_update.()")
print("差异更新，没有返回值，直接修改集合")
number = {1, 2, 3, 4, 5, 6, 8, 9}
number1 = {2, 3, 8, 9, 11, 12, 10}
number.difference_update(number1)
print(number)
print(".discard()")
print("移除指定元素，如果集合内没有指定的元素，就什么都不做")
number = {1, 2, 3, 4, 5, 6, 8, 9}
number.discard(1)
print(number)
print(".intersection()")
print("交集，可以用&代替")
number = {1,2,3,4,5,6,8,9,13}
number1 = {1,2,3,4,5,13,16,17}
print(number.intersection(number1))
print(number & number1)
print(".intersection_update()")
print("交集更新，没有返回值，直接修改集合")
number = {1,2,3,4,5,6,8,9,13}
number1 = {1,2,3,4,5,13,16,17}
number.intersection_update(number1)
print(number)
print("isdisjoint()")
print("当两个集合没有交集的时候，返回True，否则返回False")
number = {1,2,3,4,5,6,8,9,13}
number1 = {16, 17}
print(number.isdisjoint(number1))
print(".issubset()")
print("当有2个集合A和B，A.issubset(B)，A是否被B包含，如果是则返回True，否则返回False")
number = {1,2,3,4,5,6,8,9,13, 16, 17}
number1 = {16,17}
print(number1.issubset(number))
print(".issuperset(）")
print("当有2个集合A和B，A.issuperset(B)，A是否包含B，如果包含则返回True，否则返回False")
number = {1,2,3,4,5,6,8,9,13,16,17}
number1 = {16, 17}
print(number.issuperset(number1))
print(".symmetric_difference()")
print("取两个集合的差集，即取两个集合中对方都没有的元素")
number = {1, 2, 3, 4, 5, 6, 8, 9, 13, 16, 17}
number1 = {16, 17, 18, 19}
print(number.symmetric_difference(number1))
print(".symmetric_difference_update()")
print("取两个集合的差集，即取两个集合中对方都没有的元素,并更新到集合中")
number = {1, 2, 3, 4, 5, 6, 8, 9, 13, 16, 17}
number1 = {16, 17, 18, 19}
number.symmetric_difference_update(number1)
print(number)
print(".update()")
print("取两个集合的并集 并更新到集合中")
number = {1, 2, 3, 4, 5, 6, 8, 9, 13, 16, 17}
number1 = {16, 17, 18, 19}
number.update(number1)
print(number)
print("七 字典")
# 在python里面，字典就是一系列的 键-值，每个值都与一个值是一一对应的，
# 键可以是数字、字符串、列表和字典。实际上，可以将任何python对象用作字典的值。
info = {
'name': 'Frank',
'age': 23,
'hobby': 'reading',
'address': 'Shanghai',
}
print(info)
print(info['age'])
print(".keys()")
print("取出字典的键")
print(info.keys())
print(".values()")
print("取出字典的值")
print(info.values())
print(".pop()")
print("弹出一个键值对 必须指定键")
info.pop('name')
print(info)
print(".clear()")
print("清空字典里的键值对")
info.clear()
print(info)
print(".update()")
print("更新字典，如果有2个字典A和B，A.update(B),A和B相同的键的值会被B更新，而B中没有的键值对会被添加到A中")
info_new = {
'age': 24,
'hobby': 'sleeping',
'QQ': '110110',
}
info = {
'name': 'Frank',
'age': 23,
'hobby': 'reading',
'address': 'Shanghai',
}
info.update(info_new)
print(info)
print(".copy()")
print("复制字典")
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
}
# 浅拷贝
info_new = info.copy()
info['name']='Jack'
info['hobby'][0]='writing'
print(info)
print(info_new)
# 深拷贝
print("我们会发现和列表中的copy一样，也存在字典里面的列表的元素被修改后，复制的字典也会自动修改，这个原因其实和前面的是一样的，我们这里也可以使用deep.copy")
print("深拷贝")
import copy
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
}
info_new = copy.deepcopy(info)
info['name']='Jack'
info['hobby'][0]='writing'
print(info)
print(info_new)
print("那字典里的字典会不会出现相同的问题呢？")
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
'language': {1: 'Python', 2: 'Go'},
}
info_new = info.copy()
info['name']='Jack'
info['hobby'][0]='writing'
info['language'][2]='Java' # 键值对
print(info)
print(info_new)
print("答案是，是的，当我们想在修改原字典的时候，复制的字典保持不变，还是可以使用deep.copy来解决这个问题")
import copy
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
'language': {1: 'Python', 2: 'Go'},
}
info_new = copy.deepcopy(info)
info['name']='Jack'
info['hobby'][0]='writing'
info['language'][2]='Java'
print(info)
print(info_new)
print(" 这也是我们常说的深浅copy！")
print(".fromkeys()")
print("用来创建一个新的字典")
key = (1, 2, 3, 4, 5)
value = 'Python'
print(dict.fromkeys(key, value))
print(".get()")
print("根据键返回值，没有键则返回None")
info = {
'name': 'Frank',
'age': 23,
'hobby':['reading', 'sleep'],
'address': 'Shanghai',
}
print(info.get('hobby'))
print(" .items()")
print("返回dict_items()，一般结合for循环使用")
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
}
print(info.items())
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
}
for k, v in info.items():
print(k, "---", v)
print(".popitem()")
print("弹出最后一个键值,会返回一个元组，当弹空字典会报错")
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
'address': 'Shanghai',
}
print(info.popitem())
info.popitem()
print(info)
print(".setdefault(key,value）")
print("如果键在字典中，则返回这个键的值，如果不在字典中，则向字典中插入这个键，并返回value，默认value位None")
info = {
'name': 'Frank',
'age': 23,
'hobby': ['reading', 'sleep'],
}
print(info.setdefault('name')) # 存在键name,返回值
print(info)
print(info.setdefault('address', 'shanghai')) # 不存在键address,返回'shanghai'，添加键值对
print(info)
print(info.setdefault('QQ')) # 不存在键QQ，添加键QQ，返回None
print(info)
#########################################################################################
C:\Anaconda3\python.exe H:/python/venv/text
.extend()
函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
['Saber', 'Frank', 'Mei', 'Jack']
insert()
插入元素，需要指定索引值来插入
['Jack', 'Saber', 'Frank']
.pop()
弹出元素，默认弹出最后一个元素，可以指定索引，弹出对应的元素，当列表弹空或者没有指定的索引值会报错，并返回弹出的值
['Saber', 'Frank', 'Caroline']
['Saber', 'Caroline', 'Jack']
.remove()移除指定的元素
['Saber', 'Caroline', 'Jack']
.reverse()列表反转，永久修改
['Jack', 'Caroline', 'Frank', 'Saber']
.sort()对列表进行排序，永久修改，如果列表中同时存在不同类型的数据，则不能排序，比如含有整型和字符串，传递reverse=True可以倒着排序。
['1', 'Caroline', 'Frank', 'Jack', 'Saber', 'abc', 'xyz']
['xyz', 'abc', 'Saber', 'Jack', 'Frank', 'Caroline', '1']
[1, 2, 3, 12, 32, 42, 43, 543]
[543, 43, 42, 32, 12, 3, 2, 1]
五、元组
.count()
3
.index(）
查找指定元素的索引，可以指定索引范围来查找
1
2
六、集合
{1, 2, 3, 4, 5, 6}
{1, 2, 6, 8, 9, 10}
.remove()
移除指定的元素
{1, 2, 3, 4, 5, 6}
{2, 3, 4, 5, 6}
.pop()弹出排序过后的第一个元素
{1, 2, 3, 4, 5, 6}
1
{2, 3, 4, 5, 6}
.clear()清空列表返回set()
{1, 2, 3, 4, 5, 6}
set()
.copy()复制集合
{1, 2, 3, 4, 5, 6}
{2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
.add()
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7}
.difference()求差集 可以用-代替
{1, 4, 5, 6}
{10, 11, 12}
{1, 4, 5, 6}
{10, 11, 12}
.union()求并集 可以用|代替
{1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12}
{1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12}
difference_update.()
差异更新，没有返回值，直接修改集合
{1, 4, 5, 6}
.discard()
移除指定元素，如果集合内没有指定的元素，就什么都不做
{2, 3, 4, 5, 6, 8, 9}
.intersection()
交集，可以用&代替
{1, 2, 3, 4, 5, 13}
{1, 2, 3, 4, 5, 13}
.intersection_update()
交集更新，没有返回值，直接修改集合
{1, 2, 3, 4, 5, 13}
isdisjoint()
当两个集合没有交集的时候，返回True，否则返回False
True
.issubset()
当有2个集合A和B，A.issubset(B)，A是否被B包含，如果是则返回True，否则返回False
True
.issuperset(）
当有2个集合A和B，A.issuperset(B)，A是否包含B，如果包含则返回True，否则返回False
True
.symmetric_difference()
取两个集合的差集，即取两个集合中对方都没有的元素
{1, 2, 3, 4, 5, 6, 8, 9, 13, 18, 19}
.symmetric_difference_update()
取两个集合的差集，即取两个集合中对方都没有的元素,并更新到集合中
{1, 2, 3, 4, 5, 6, 8, 9, 13, 18, 19}
.update()
取两个集合的并集 并更新到集合中
{1, 2, 3, 4, 5, 6, 8, 9, 13, 16, 17, 18, 19}
七 字典
{'name': 'Frank', 'age': 23, 'hobby': 'reading', 'address': 'Shanghai'}
23
.keys()
取出字典的键
dict_keys(['name', 'age', 'hobby', 'address'])
.values()
取出字典的值
dict_values(['Frank', 23, 'reading', 'Shanghai'])
.pop()
弹出一个键值对 必须指定键
{'age': 23, 'hobby': 'reading', 'address': 'Shanghai'}
.clear()
清空字典里的键值对
{}
.update()
更新字典，如果有2个字典A和B，A.update(B),A和B相同的键的值会被B更新，而B中没有的键值对会被添加到A中
{'name': 'Frank', 'age': 24, 'hobby': 'sleeping', 'address': 'Shanghai', 'QQ': '110110'}
.copy()
复制字典
{'name': 'Jack', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai'}
{'name': 'Frank', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai'}
我们会发现和列表中的copy一样，也存在字典里面的列表的元素被修改后，复制的字典也会自动修改，这个原因其实和前面的是一样的，我们这里也可以使用deep.copy
深拷贝
{'name': 'Jack', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai'}
{'name': 'Frank', 'age': 23, 'hobby': ['reading', 'sleep'], 'address': 'Shanghai'}
那字典里的字典会不会出现相同的问题呢？
{'name': 'Jack', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai', 'language': {1: 'Python', 2: 'Java'}}
{'name': 'Frank', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai', 'language': {1: 'Python', 2: 'Java'}}
答案是，是的，当我们想在修改原字典的时候，复制的字典保持不变，还是可以使用deep.copy来解决这个问题
{'name': 'Jack', 'age': 23, 'hobby': ['writing', 'sleep'], 'address': 'Shanghai', 'language': {1: 'Python', 2: 'Java'}}
{'name': 'Frank', 'age': 23, 'hobby': ['reading', 'sleep'], 'address': 'Shanghai', 'language': {1: 'Python', 2: 'Go'}}
这也是我们常说的深浅copy！
.fromkeys()
用来创建一个新的字典
{1: 'Python', 2: 'Python', 3: 'Python', 4: 'Python', 5: 'Python'}
.get()
根据键返回值，没有键则返回None
['reading', 'sleep']
.items()
返回dict_items()，一般结合for循环使用
dict_items([('name', 'Frank'), ('age', 23), ('hobby', ['reading', 'sleep']), ('address', 'Shanghai')])
name --- Frank
age --- 23
hobby --- ['reading', 'sleep']
address --- Shanghai
.popitem()
弹出最后一个键值,会返回一个元组，当弹空字典会报错
('address', 'Shanghai')
{'name': 'Frank', 'age': 23}
.setdefault(key,value）
如果键在字典中，则返回这个键的值，如果不在字典中，则向字典中插入这个键，并返回value，默认value位None
Frank
{'name': 'Frank', 'age': 23, 'hobby': ['reading', 'sleep']}
shanghai
{'name': 'Frank', 'age': 23, 'hobby': ['reading', 'sleep'], 'address': 'shanghai'}
None
{'name': 'Frank', 'age': 23, 'hobby': ['reading', 'sleep'], 'address': 'shanghai', 'QQ': None}
Process finished with exit code 0
#########################################################################################