python基础：数据类型与基本语句

python基础

Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: utf-8 -*-

标识符

• 第一个字符必须是字母表中字母或下划线 _ 。

• 标识符的其他的部分由字母、数字和下划线组成。

• 标识符对大小写敏感。

标准内置函数

python 变量

• 变量的赋值，只是表示让变量指向了某个对象，并不表示拷贝对象给变量；而一个对象，可以被多个变量所指向。

• 可变对象（列表，字典，集合等等）的改变，会影响所有指向该对象的变量。

• 对于不可变对象（字符串，整型，元祖等等），所有指向该对象的变量的值总是一样的，也不会改变。但是通过某些操作（+= 等等）更

• 新不可变对象的值时，会返回一个新的对象。

• 变量可以被删除，但是对象无法被删除。

python 运算符

算术运算符

比较运算符

赋值运算符

位运算符

逻辑运算符

成员运算符

身份运算符

数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

数字类型

• 整数 int

• 浮点数 float

• 复数 complex

布尔型 bool

• Ture

• Flase

数字类型操作

运算符

+
-
*
/
//（整数商）
**（幂）

运算函数

• abs(x) 绝对值

• pow(x,y) x**y(x的次方）

• round(x,n) 对x四舍五入，保留n位小数，

省略n则返回x四舍五入的整数值

• max(x1,x2,....xn) 返回最大值

• min(x1,x2......xn) 返回最小值

转换函数

• int(x)

• float(x)

• coplex(re,im)

序列类型

序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可以通过每个值所在的位置编号(即索引)进行访问。
Python中字符串、列表、元组、字典、集合都是序列，列表和元组中的数据是有序的，可以通过索引访问；而字典和集合是无序的，它们不支持索引、切片、相加、相乘操作。

索引方法

str[start:end:step]
    start:起始下标（包含）
    end:结束下标（不包含）
    step:步长(为负数则逆向读取)
        
        str="1234567890f"
        print(str[1:-4])
        print(str[-4:1:-1])
        print(str[-1::-1])  # 此方法翻转字符串
        # 结果
        # 234567
        # 876543
        # f0987654321

内置序列函数

• len() 返回字符长度或元素个数

• type() 返回变量数据类型

• max() 返回最大值

• min() 返回最小值

• sum() 求和

计算序列中元素的和，使用该函数时，序列中元素必须都是数字，不能是字符或字符串，否则会报错。因为Python解释器无法判断‘+’是要做求和运算还是序列连接操作

• list() 将序列转化为列表

• str() 将序列转化为字符串

• tuple() 将序列转化为元组

• sorted() 对序列中元素进行排序

sorted(iterable, /, *, key=None, reverse=False)
    iterable：待排序的序列
    key：排序规则
    reverse：指定排序的方式，默认值False，即升序排列,Ture为降序

• reversed() 元素反向

将序列中的元素反向，不会改变原序列顺序，而是指向一个新的地址
不可直接输出 
用list() 或tuple() 才能读取地址中的数据

• enumerate() 将序列索引和序列元素组合成元组，形成一个新序列

字符串

表示方法

'单引号'

"双引号"

'''三引号'''

单引号中能包含双引号，双引号中能包含单引号

三引号能包含单双引号，能换行

转义字符 \

r “\n” 不转义

操作符

+    *   in   str[i]索引    str[N:M]切片索引   

内置字符串方法

• str.capitalize() 首字母转大写

1. 如果字符串的第一个字符是数字或标点符号或空格字符，则该方法不会做任何转换。

2. 如果字符串只包含非字母字符，则该方法返回原始字符串。

3. 如果字符串全是大写，则该方法除首字母外，其他字母转换为小写字母。

4. 该方法返回一个新的字符串，原始字符串不会被修改。

s1 = "hello world"
print(s1.capitalize())  # 输出 "Hello world" (将字符串的首字母转换为大写字母)

s2 = "HELLO WORLD"
print(s2.capitalize())  # 输出 "Hello world"（除首字母外，其他字母转换为小写字母）

s3 = "12345"
print(s3.capitalize())  # 输出 "12345"（数字和标点符号不转换）

s4 = " hello!"
print(s4.capitalize())  # 输出 " hello!"（如果字符串的第一个字符是数字/标点符号/空格字符，则该方法不会做任何转换）

• str.upper() 所有字母大写

1.upper()方法返回字符串的全体大写形式。对于英文字符，这通常是将所有小写字母转换为大写字母。对于非英文字符，情况就比较复杂，因为这些字符可能没有对应的大写形式。例如，一些语言中的特殊字符在转换为大写后可能会失去一些语义信息。

2.upper()方法只能用于字符串类型的变量。如果尝试在非字符串类型的变量（如整数或浮点数）上使用upper()方法，将会引发TypeError。

3.对于空字符串，upper()方法返回的仍然是空字符串。这是因为空字符串没有大写形式。

4.在某些情况下，可能需要使用其他字符串方法（如capitalize()）来获得期望的文本转换效果。这些方法可以更精细地控制文本的转换方式。

• str.lower() 所有字母小写

1. str.lower()方法只将大写字母转换为小写字母，不会删除任何字符或空格。

2. 与str.casefold()方法相比，str.lower()方法更简单、更快速，因为它不删除大小写差异。

3. str.lower()方法返回一个新的字符串，原始字符串不会被修改。

• str.center() 将字符串居中

将字符串居中，并使用空格或其他字符进行填充。它常用于格式化输出，使字符串在指定的宽度内居中对齐。在使用该方法时，需要注意 width 和 fillchar 参数的使用，以确保得到正确的结果。

str.center(width, fillchar=None)

str.center(width)：将字符串居中，使用空格填充到指定的宽度。如果字符串的长度已经超过了指定的宽度，则返回原始字符串。
str.center(width, fillchar)：将字符串居中，使用指定的字符填充到指定的宽度。如果字符串的长度已经超过了指定的宽度，则返回原始字符串。

1.width 参数必须是一个非负整数，表示要填充的宽度。

2.fillchar 参数是可选的，默认为 None。如果提供了该参数，则使用指定的字符进行填充。如果未提供该参数，则使用空格进行填充。

3.如果字符串的长度已经超过了指定的宽度，则返回原始字符串。

4.该方法返回一个新的字符串，原始字符串不会被修改。

• str.count() 统计出现次数

语法:计算字符串中某个子字符串的出现次数，也可以用于计算字符串中某个子字符串在指定范围内的出现次数。

str.count(sub[, start[, end]])

如果子字符串不存在于字符串中，则返回0。

如果start或end参数超出字符串范围或未指定，则默认为0和字符串的长度。

如果start或end参数为负数，则将其视为从字符串末尾开始的偏移量。

str.count()方法不会修改原始字符串。

在使用str.count()方法时，应注意与其他方法结合使用以获得更好的效果。例如，可以使用str.find()方法查找子字符串的位置，然后使用str.count()方法计算子字符串的出现次数。

• str.endswith() 检查结尾

语法：检查字符串是否以指定的后缀结尾，如果是则返回True，否则返回False。

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

endswith()方法只检查字符串的结尾，所以它从字符串的末尾开始比较。

如果要检查的子串不在字符串的末尾，该方法返回False。

endswith()方法对大小写敏感，所以"Hello"和"hello"是不同的。

如果提供了start和end参数，那么比较将在指定的范围内进行。这意味着，例如，对于字符串"Hello, World!"，

s.endswith("World!", 7, 13)将返回True，而s.endswith("World!", 0, 5)将返回False。

endswith()方法不能接受非字符串类型的参数。尝试这样做将引发TypeError。

空字符串""是任何字符串的结尾，所以s.endswith("")将返回True。

• str.find() 查找索引位置

str.rfind() 从右向左查找

语法：返回子字符串在字符串中第一次出现的索引位置，如果没有找到则返回-1。

str.find(sub[, start[, end]])

find()方法返回子串在字符串中第一次出现的位置。如果没有找到子串，则返回-1。

start和end参数是可选的，用于指定搜索的子串范围。如果不指定这些参数，则默认在整个字符串中进行搜索。

如果子串为空字符串，则它在任何字符串中都存在，并且其位置为0。

find()方法对大小写敏感，所以"Hello"和"hello"是不同的。但是，可以使用lower()或casefold()方法进行大小写不敏感的搜索。

find()方法不支持正则表达式。如果需要使用正则表达式进行搜索，可以使用re模块中的search()或findall()方法。

在使用start和end参数时，请确保指定的范围是有效的，否则可能会引发ValueError。

• str.index() 子字符串首次出现

str.rindex() 从末尾查找

用于查找子字符串在字符串中首次出现的位置。如果找不到子字符串，则会引发一个 ValueError 异常。

str.index(sub, start=0, end=len(string))
    sub：要查找的子字符串。
    start 和 end：可选参数，指定查找的子字符串的起始和结束位置。

使用 index() 方法时，应确保要查找的子字符串确实存在于原始字符串中，否则会引发异常。为了避免异常，可以使用 find() 方法代替，它在找不到子字符串时会返回 -1 而不是引发异常。

使用负数索引时，注意索引的有效范围。在 Python 中，-1 表示最后一个字符，-2 表示倒数第二个字符，以此类推。

当使用起始和结束位置参数时，应确保这些参数的有效性，即它们不应该超出字符串的长度或为负数。否则，ValueError 异常会被引发。

如果查找的子字符串有多个相同的实例，index() 方法只会返回第一个实例的位置。如果需要找到所有实例的位置，可以考虑使用其他方法或自己编写循环来遍历并查找。

注意大小写敏感性。默认情况下，index() 方法是大小写敏感的，所以 “Hello” 和 “hello” 是不同的字符串。如果要进行大小写不敏感的比较，可以先将字符串转换为全部小写或全部大写。

• str.title() 单词首字母大小

语法：将字符串中每个单词的首字母转换为大写，其余部分转换为小写。

str.title()

title()方法会将字符串中每个单词的首字母转换为大写，其余部分转换为小写。对于英文字符，这通常是将每个单词的首字母转换为大写。对于非英文字符，情况就比较复杂，因为这些字符可能没有对应的大写形式。例如，一些语言中的特殊字符在转换为大写后可能会失去一些语义信息。

title()方法只作用于空格分隔的单词。它不会对标点符号或其他特殊字符进行任何处理。因此，如果字符串中包含标点符号或其他特殊字符，它们将保持不变。

title()方法不会删除字符串中的空格或其他空白字符。如果需要删除这些字符，可以使用strip()方法或replace()方法来处理。

title()方法不会修改原始字符串。它会返回一个新的字符串，其中每个单词的首字母都已转换为大写。原始字符串保持不变。

• str.replace() 替换指定子串

语法：在字符串中替换指定的子串。这个方法接受两个参数：要被替换的子串（old）和用来替换的新子串（new）。

str.replace(old, new[, count])
    old：需要被替换的子串。
    new：用来替换的新子串。
    count：可选参数，指定替换的次数。如果不指定，将替换所有匹配项。如果指定了某个数值，则只替换前count个匹配项。

1. replace()方法返回一个新的字符串，原始字符串不会被修改。

2. 如果old参数为空字符串，则字符串每个字符之间都会添加new参数指定的字符串（示例4）。

3. 如果new参数为空字符串，则匹配到的子串会被删除（示例5）。

• str.join() 对象元素连接

语法：将一个可迭代对象（如列表或元组）中的所有元素连接成一个新的字符串。

str.join(iterable)
    iterable：可迭代对象，如列表或元组。
    
l=['3','4','5']
print(''.join(l))   # 345
print(' '.join(l))  # 3 4 5
print(','.join(l))  # 3,4,5

str.join()方法返回一个新的字符串，原始的可迭代对象不会被修改。

如果可迭代对象中的元素不是字符串类型，将会引发TypeError。因此，在使用str.join()方法之前需要确保可迭代对象中的元素都是字符串类型。

如果不指定分隔符，则默认使用空字符串作为分隔符。这意味着所有元素将会被连接成一个连续的字符串。

• str.split() 分割字符串，返回列表

str.split(separator, maxsplit)
    separator：可选参数，指定分隔符。可以是任意字符串，默认为 None。如果没有指定分隔符，则默认按照空格进行切割
    maxsplit：可选参数，指定最大分割次数。如果指定了该参数，则最多会按照 maxsplit 次分隔符进行切割。

str.split() 方法返回一个列表，列表中的每个元素是原字符串根据分隔符分割后的子串。

如果省略了 separator 参数，则默认按照空格进行切割。但是，如果字符串中有连续的空格，则它们也会被视为分隔符。

maxsplit 参数是可选的，如果不指定，则默认会分割所有可能的子串。如果指定了该参数，则最多会按照 maxsplit 次分隔符进行切割。需要注意的是，如果 maxsplit 的值大于实际分隔符的数量，则只会分割出有限个子串。

• str.strip() 删除字符串两端的空白字符

str.strip([chars])
    chars：可选参数，指定要删除的字符。如果不指定，将删除所有空白字符。

1. strip()方法返回一个新的字符串，原始字符串不会被修改。

2. 如果不指定chars参数，strip()方法将删除所有空白字符（包括空格、换行符、制表符等）。如果指定了chars参数，它将删除指定的字符。如果chars参数为空字符串，则不会删除任何字符。

• str.isalpha() 全字母检查

用于检查字符串中的所有字符是否都是字母。如果字符串中的所有字符都是字母并且字符串不为空，则返回 True，否则返回 False。

string.isalpha()

• str.isdigit() 全数字检查

用于检查字符串是否只包含数字字符。如果字符串中的所有字符都是数字，则返回 True，否则返回 False。

string.isdigit()

• str.isalnum() 字母和数字检查

• str.isupper() 全大写检查

• str.islower() 全小写检查

• str.isspace(） 全空白符检查

用于检查字符串中的所有字符是否都是空白字符。空白字符包括空格、制表符、换行符等。如果字符串中的所有字符都是空白字符，则返回 True，否则返回 False。

• str.format() 格式化字符串

"{}".format(value)
"{:format_specifier}".format(value)

    {}：表示将要插入的值的占位符。
    format_specifier：一个可选的格式说明符，用于指定值的格式。例如，{:d} 用于整数，{:.2f} 用于保留两位小数的浮点数等。

使用 str.format() 时，占位符 {} 可以根据需要包含一个或多个参数，这些参数将按照顺序被后面的 .format() 方法中的值替换。也可以使用位置参数（如 {0}、{1} 等）来指定参数的位置。

格式说明符（如 {:d}、{:.2f} 等）用于进一步指定值的格式，可以根据需要组合使用。例如，使用不同的数字格式、指定日期格式等。如果不指定格式说明符，将使用默认的格式。

在使用 str.format() 时，需要注意占位符和格式说明符的正确使用，以避免出现格式错误或意外的输出结果。同时，也要注意处理可能出现的异常情况，如参数数量不匹配等。

字符串的格式

%号

# 1、格式的字符串（即%s）与被格式化的字符串（即传入的值）必须按照位置一一对应
# ps：当需格式化的字符串过多时，位置极容易搞混
print('%s asked %s to do something' % ('egon', 'lili'))  # egon asked lili to do something
print('%s asked %s to do something' % ('lili', 'egon'))  # lili asked egon to do something

# 2、可以通过字典方式格式化，打破了位置带来的限制与困扰
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % {'name': 'egon', 'age': 18})

kwargs={'name': 'egon', 'age': 18}
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % kwargs)

str.format

使用位置参数:
    # 按照位置一一对应
    print('{} asked {} to do something'.format('egon', 'lili'))  # egon asked lili to do something
    print('{} asked {} to do something'.format('lili', 'egon'))  # lili asked egon to do something

使用索引:
    # 使用索引取对应位置的值
    print('{0}{0}{1}{0}'.format('x','y')) # xxyx


使用关键字参数or字典:
    # 可以通过关键字or字典方式的方式格式化，打破了位置带来的限制与困扰
    print('我的名字是 {name}, 我的年龄是 {age}.'.format(age=18, name='egon'))

    kwargs = {'name': 'egon', 'age': 18}
    print('我的名字是 {name}, 我的年龄是 {age}.'.format(**kwargs)) # 使用**进行解包操作

填充与格式化

先取到值,然后在冒号后设定填充格式：

"{:[填充字符] [对齐方式] [宽度] [千位分割符] [精度] [类型]}"

列表 list []

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

表示方法

[ ]

索引方法

与字符串相同

列表操作

+    *   in   str[i]索引    str[N:M]切片索引 

del 删除列表

内置列表方法

• List append() 末尾添加元素

• List count() 统计元素次数

• List extend() 末尾扩充多个元素

用列表扩展列表

List index() 查找元素首次索引

list.index(x[, start[, end]])
    
    x-- 查找的对象。
    start-- 可选，查找的起始位置。
    end-- 可选，查找的结束位置。

List insert() 插入列表元素

list.insert(index, obj)
    
    index -- 对象obj需要插入的索引位置。
    obj -- 要插入列表中的对象。

List pop() 删除指定索引元素

返回删除的元素值

list.pop([index=-1])
    index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
    括号里没有参数，表示删除list数组中最后一个元素

List remove() 移除第一个匹配元素

list.remove(obj )

List reverse() 反向列表元素

List sort() 元素排序

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

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

List clear() 清空列表元素

List copy() 复制列表

元组 tuple ()

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组中的元素值是不允许修改的

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

元组的不可变指的是元组所指向的内存中的内容不可变。

字典 dict {}

字典是另一种可变容器模型，且可存储任意类型对象。

表示方法

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

字典操作

访问值：将相应的键放入 [ ]

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

输出
tinydict['Name']:  Runoob
tinydict['Age']:  7

修改字典：键/值对一起操作

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
 
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

in

python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

遍历字典

person = {'name': '王大锤', 'age': 55, 'height': 168, 'weight': 60, 'addr': '成都市武侯区科华北路62号1栋101'}

for key in person:
    print(key)
    
上方法只能遍历到字典的键

person = {'name': '王大锤', 'age': 55, 'height': 168, 'weight': 60, 'addr': '成都市武侯区科华北路62号1栋101'}

for key in person:
    print(person[key])
    
使用键可访问到值

字典生成式

ad={x:x+1 for x in range(1,10,2)}
print(ad) # {1: 2, 3: 4, 5: 6, 7: 8, 9: 10}

zd={key:value for key,value in [('a',1),('b',2),('c',3)]}
print(zd) # {'a': 1, 'b': 2, 'c': 3}


stocks = {
    'AAPL': 191.88,
    'GOOG': 1186.96,
    'IBM': 149.24,
    'ORCL': 48.44,
    'ACN': 166.89,
    'FB': 208.09,
    'SYMC': 21.29
}
stocks2 = {key: value for key, value in stocks.items() if value > 100}
print(stocks2)  ]
# {'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ACN': 166.89, 'FB': 208.09}

内置字典方法

• dict.clear() 删除所有元素

• dict.copy() 浅复制字典

返回一个字典的浅复制。

dict.fromkeys() 创建字典

创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

dict.fromkeys(seq[, value])

    seq -- 字典键值列表。
    value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。

该方法返回一个新字典。

dict.get() 返回指定键的值

返回指定键的值，如果键不在字典中返回默认值，如果不指定默认值，则返回 None。

dict.get(key[, value]) 

    key -- 字典中要查找的键。
    value -- 可选，如果指定键的值不存在时，返回该默认值。

get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。

统计字母出现次数

sentence = input('请输入一段话: ')
counter = {}
for ch in sentence:
    if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
        counter[ch] = counter.get(ch, 0) + 1
sorted_keys = sorted(counter, key=counter.get, reverse=True)
for key in sorted_keys:
    print(f'{key} 出现了 {counter[key]} 次.')

嵌套使用:

tinydict = {'RUNOOB' : {'url' : 'www.runoob.com'}}
res = tinydict.get('RUNOOB').get('url')
# 输出结果
print(res)  # www.runoob.com

dict.items() 返回视图 键值对

Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对。

dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。

视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。

我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

dict.keys() 返回视图 键

dict.values() 返回视图 值

dict.setdefault() 返回指定键的值，添加查找不到的键

Python 字典 setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dict.setdefault(key, default=None)

    key -- 查找的键值。
    default -- 键不存在时，设置的默认键值。
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。 

dict.update(dict2) 更新字典键值

dict.update(dict2)
    dict2 -- 添加到指定字典dict里的字典。
    
    #!/usr/bin/python3
 
    tinydict = {'Name': 'Runoob', 'Age': 7}
    tinydict2 = {'Sex': 'female' }

    tinydict.update(tinydict2)
    print ("更新字典 tinydict : ", tinydict)   
    # 更新字典 tinydict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}

dict.pop() 删除键对应值

Python 字典 pop() 方法删除字典 key（键）所对应的值，返回被删除的值。

pop(key[,default])
    key - 要删除的键
    default - 当键 key 不存在时返回的值

• 如果 key 存在 - 删除字典中对应的元素

• 如果 key 不存在 - 返回设置指定的默认值 default

• 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常

dict.popitem() 返回并删除最后插入的键值对

返回最后插入键值对(key, value 形式)，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。

注意：在 Python3.7 之前，popitem() 方法删除并返回任意插入字典的键值对。

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}

# ('url': 'www.runoob.com') 最后插入会被删除
print(site.popitem())
print(site)

# 插入新元素
site['nickname'] = 'Runoob'
print( site)

# 现在 ('nickname', 'Runoob') 是最后插入的元素
print(site.popitem())
print(site)

输出：
('url', 'www.runoob.com')
{'name': '菜鸟教程', 'alexa': 10000}
{'name': '菜鸟教程', 'alexa': 10000, 'nickname': 'Runoob'}
('nickname', 'Runoob')
{'name': '菜鸟教程', 'alexa': 10000}

返回最后插入键值对 且为元组类型

集合 set {}

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

集合中的元素必须是不变类型的

表示方法

parame = {value01,value02,...}
或者
set(value)

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合操作

in 
not in



ja=set("abcdefj")
jb=set("asdfghj")
print(ja)
print(jb)

print(ja-jb)  # {'b', 'c', 'e'}集合a中包含而集合b中不包含的元素
print(ja|jb)  # {'f', 'h', 'a', 'j', 'g', 's', 'd', 'c', 'b', 'e'} 集合a和b中包含的所有元素
print(ja&jb)   # {'d', 'j', 'a', 'f'} # 集合a和b中都包含了的元素
print(ja^jb) # {'b', 'c', 's', 'g', 'h', 'e'}不同时包含于a和b的元素


混合运算
==
!=
ja|=jb  等效于  ja=ja|jb

内置集合方法