python基础

1.注释

# 单行注释

'''   '''或者"""  """都是多行注释     --不能用在语句末尾

2.变量

a = 1  # a不能为关键字，只能由数字、字母、下划线组合而成，首字母是不能为数字，且区分大小写。

3.标识符的命名规范

标识符：文件名，变量名，函数名，类型名

大驼峰命名法：ClassName        #所有单词首字母大写

小驼峰命名法：className        #第一个单词首字母小写，后面单词首字母大写

下划线命名法：class_name        #单词之间用下划线连接

4.数据类型

基础数据类型：int 整数        float 浮点        bool 布尔

容器类型：str 字符串       list 列表       tuple 元祖       set 集合       dict 字典

数据类型查看的函数type(数据名/变量名)

5.格式化输出、占位符

字符串数据使用%s

浮点型数据使用%f

整数型数据使用%d

name = 'xiaoming'
age = 18
height = 1.85
id = 12
print('学员的姓名是%s’ % name)
print('学生的姓名是%s,年龄是%d岁，身高是%.2f米，ID是%06d' % (name, age, height, id))

6.转义字符

\n        换行符

\t        制表符，相当于4空格

%%        %，在使用字符串格式化时，字符串中的%不能单独输出

print(12\t3, end='$$$')        end默认为\n

7.f-string

是python3.6版本以后推出的格式化方式

name = 'xiaoming'
age = 18
height = 1.85
weight = 69.5
score = 98
id = 123456
print(f'学员的姓名是{name},年龄是{age}，身高是{height:.2f},体重是{weight:.3f}，分数是{score}%，id是{id:08d}')

8.input函数

account = input('请输入您的账号:')

password = input('请输入您的密码:')

传入的参数是str类型，整数和浮点类型需要进行类型转换

9.类型转换

aple_price = float(input('请输入苹果的价格:'))        #转换为浮点类型

float转换为int类型会去除小数

int转换为float类型会自动添加小数

float和int可以随意转换为str类型，反之则必须为int或float类型数据

10.算数运算符

#     +        -        *        /        %        //        **

数值型数据(float, int, bool)可以进行运算,Ture 代表1        False 代表0

11 / 4         # 商 2          余3

11 // 4        # 取商 2

11 % 4        # 取余/取模 3

print(int1 ** 2)        # int1的平方 取立方直接把2替换为3就是3次方

print(int1 ** 0.5)        # int1的开根号可以用0.5

print(9 / 3)       # 3.0 ，除法运算的结果一定是float浮点型

优先级：+ -   <   乘 除 取商 取余   <   **   <   括号

11.比较运算符

<, >, >=, <=, !=, ==        # <>这个不等于不可以使用

12.逻辑运算符

and 同真即真，否则为假

or 同假为假，否则为真

not 真变假，假变真

在数值型数据中，非0即真，在容器型数据中，非空即真

13.if条件语句

age = int(input('请输入年龄'))
if age < 0 or age > 100:
    print('数据错误')
elif age > 18:
    print('可以去网吧')
else:
    print('不能进网吧')
print('回家睡觉')

从上而下执行，如果上面的if条件成立，则下面的条件不会再进行判断

if嵌套

num = -12
if num < 0:
    print('负', end='')
    if num % 2 == 0:
        print('偶数')
    else:
        print('奇数')
else:
    if num % 2 == 0:
        print('正偶数')
    else:
        print('正奇数')

14.while循环 和 for循环

i = 1
sum = 0
while i <= 100
    if i % 2 == 0:
        sum += i
    i += 1
print(f'1-100的偶数和为{sum}')

break：退出当前循环

continue：跳出本次循环，执行下一次循环

while循环和for循环的差别是while会有死循环，如果没有明确的跳出条件就for循环，因为for循环语法更简单。

range函数

range(起始值，结束值，步长)

for i in range(1,10,1):
print(i)
print(list(range(10)))
# 初始值，默认为0，步长默认为1，起始值省略，步长也得省略

九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{j} * {i} = {i * j}', end='\t')
    print()

过7游戏

# 需求: 叔叔,1-100  凡是7 和 7的倍数,以及数字中带7的所有数字, 输出 哈  否则 输出数字
# 获取十位数字:  i // 10 == 7
# 获取各位数字:  i % 10 == 7
for i in range(1, 101):
    if i % 7 == 0 or i % 10 == 7 or i // 10 == 7:
        print('哈')
    else:
        print(i)

# 需求: 1-1000  获取 各位 十位 百位
# 个位: i %10 == 7
# 十位: i // 10 % 10 = 7
# 百位: i // 100 == 7

 查找字符串

a = 'itheaima'
index = 0
char1 = input('请输入一个字母:')
for i in a:
    if i == char1:
        print('找到了')
        break
    index += 1
    if index == len(a):
        print('查无此字母')

 while ... else

i = 0
while i <= 100:
    if i == 60:
        print('下载非法文件,已经将你举报,下载终止')
        # break  # 会造成循环异常终止,不会执行else中的代码
        i += 1
        continue  # 不会造成循环异常终止,会执行else中的代码
    print(f'下载进度:{i}%')
    i += 1
else:
    print('下载完成')

for ... else

for i in range(0, 101):
    if i == 60:
        # print('别下了,网费用光了')
        # break  # 打破循环,造成循环异常结束,不会执行else 中的命令
        print('丢包,这里没有下载好继续下载别的吧')
        continue # 结束本次循环,进入下一次循环,不会造成循环异常结束,会执行else中的命令
    print(f'下载进度:{i}%')
else:
    print('下载完成')

15.字符串

15.1字符串的输入

user_name = input('请输入用户名')

print(f'您的用户名为：')

 15.2字符串的索引

'''
i  t  h  e  i  m  a
# 正数索引
0  1  2  3  4  5  6
# 负数索引
-7 -6 -5 -4 -3 -2 -1
'''
str1 = 'itheima'
print(str1[4])

15.3字符串切片

str2 = '我爱北京天安门,天安门上太阳升!'
print(str2[:7:1])  # 我爱北京天安门
print(str2[:7:-1])  # !升阳太上门安天
print(str2[8::1])  # 天安门上太阳升!
print(str2[8:-1:1])  # 天安门上太阳升
print(str2[::-1])  # !升阳太上门安天,门安天京北爱我
str3 = str2[:]
print(str3)  # 我爱北京天安门,天安门上太阳升!

15.4字符串查找

index

格式: 字符串.index(self(不用传值), sub(子字符串), start(起始位置), end(结束位置))

如果字符串中含有多个子字符串,则会返回指定范围内的从左至右的第一个查找到的子字符串位置索引

结论:找不到对应的子字符串,则会报错,如果能够查找到数据返回当前子字符串的正数索引

str1 = 'hello python'
print(str1.index('o'))  # 4
print(str1.index('o', 10, 12))  # 10

find

格式: 字符串.find(self(不用传值), sub(子字符串), start(起始位置), end(结束位置))

结论:使用find进行查询时,如果查询的子字符串不存在,则返回-1,如果存在则返回指定正数索引

str1 = 'hello python'
print(str1.find('o', 5, 10))

rfind 和 rindex

使用方式与上方完全一样，返回正数索引，只是他是从右至左查找

count() 计数

结论:1.count查询的范围是一个左闭右开区间
         2.如果没有查询到子字符串则返回0  不会报错

print(str1.count('h', 9, 12)) # 1

15.5字符串的替换

replace

格式: replace(self(不用传值), old(旧值), new(新值), count(替换次数))

str1 = 'hello python'
print(str1.replace('o', '$', 1))  # 不指定替换次数，默认全部替换

15.6字符串拆分

split

# 需求: 将所有的单词按照空格为分隔符进行拆分,拆分为多个字符串
# split 会按照指定分隔符进行拆分,拆分完成后 会将所有的拆分后的结果以字符串形式保存到列表中
# split(self(不用传值), sep(分隔符), maxsplit(最大分割次数))

str1 = 'I love Python and java and c and lixiaolong'
print(str1.split())  # ['I', 'love', 'Python', 'and', 'java', 'and', 'c', 'and', 'lixiaolong']
print(str1.split(' ', 3))  # ['I', 'love', 'Python', 'and java and c and lixiaolong']
print(str1.split('a', 60))  # ['I love Python ', 'nd j', 'v', ' ', 'nd c ', 'nd lixi', 'olong']

15.7字符串合并

join

# 将list1  按照指定分隔符❤  合并为一个字符串
# 格式:分隔符.join(iterable(可迭代类型))

str1 = 'I love Python and java and c and lixiaolong'
list1 = str1.split()
print('❤'.join(list1))  # I❤love❤Python❤and❤java❤and❤c❤and❤lixiaolong
# 进行join合并时,要注意可迭代类型中全部元素都要是字符串类型,否则无法合并

15.8字符串大小写转换

capitalize

将字符串的第一个字母大写,同时讲其余全部字母小写,  对数字和汉字等不做处理

str1 = 'hello woRld aNd Python'
print(str1.capitalize())  # Hello world and python

title

将所有的单词首字母大写,其余字母变为小写

在Python中怎样对单词进行辨别, 非字母字符都可以作为分隔符

str2 = 'hello中国python'
print(str2.title())  # Hello中国Python

upper   lower

全部变为大写或小写

# upper()将数据全部变为大写
print(str1.upper())  # HELLO WORLD AND PYTHON
# lower()将字符全部变为小写
print(str1.lower())  # hello world and python

15.9去除字符串两边指定字符

strip

去重字符串左右两侧指定字符

strip中如果不传参数,则去除字符串左右两侧的空白(包括空格,换行,制表位等)

格式:字符串.strip(self(不传值), chars(可以传一个字符或多个字符))

str1 = '    hello  python\t \n     '
print(str1.strip())  # hello  python
str2 = '$$$hello Python$$$'
print(str2.strip('$'))  # hello Python
str3 = '13214123123hello Python12314123123123'
print(str3.strip('123'))  # 4123123hello Python12314

rstrip

删除字符串右侧指定的字符

lstrip

删除字符串左侧指定的字符

str3 = '13214123123hello Python12314123123123'
print(str3.rstrip('1234'))
print(str3.lstrip('1234'))

15.10字符串对齐

rjust 右对齐

# 字符在右侧,不足位置用空格补齐
# 如果不指定填充字符,则自动用空格补齐

格式:字符串.rjust(self(不用传值), width(字符宽度), fillchar(填充字符))

str1 = 'python'
print(str1.rjust(10, '$'))  #$$$$python

ljust 左对齐

和rjust使用方式一致,只不过字符在左侧

str1 = 'python'
print(str1.ljust(10, '$'))  # python$$$$

center 居中对齐

格式: center(self(不用传值), width(字符宽度), fillchar(填充字符))

str1 = 'python'
print(str1.center(10, '*'))  # **python**

练习: 计算 1-10000中出现7的次数 (例如 77  就计算两次  777 就计算三次.... )

sum1 = 0
for i in range(1, 10001):
    sum1 += str(i).count('7')

print(sum1)

print(str(list(range(1,10001))).count('7'))

sum1 = 0
for i in range(1, 10001):
    if i % 10 == 7:
        sum1 += 1
    if i % 100 // 10 == 7:
        sum1 += 1
    if i % 1000 // 100 == 7:
        sum1 += 1
    if i // 1000 == 7:
        sum1 += 1
print(sum1)

15.11字符串判断

startswith

判断是否以...开头

# 需求:判断当前字符串是否以he开头
# 结果是布尔值

str1 = 'hello itcast'
print(str1.startswith('he'))  # True
print(str1.startswith('he', 6, 12))  # False

 endswith

判断是否以...结尾

str1 = 'hello itcast'
print(str1.endswith('st'))  # True

 is     判断

isalnum 判断是否全部为数字或字母  不能有空格

print(str1.isalnum())  # False

isspace   判断是否全部为空格

str2 = ' '
print(str2.isspace())  # True

 isnumeric  isdecimal isdigit  都是判断是否为数字的

str3 = '1234'
print(str3.isnumeric())  # True
print(str3.isdecimal())  # True
print(str3.isdigit())  # True
# 判断中文数字
str4 = '123四肆④亖零〇'
print(str4.isnumeric())  # True  这个方法可以判断中文数字和罗马数字和阿拉伯数字
print(str4.isdecimal())  # False
print(str4.isdigit())  # False

isidentifier    判断是否为标识符.

str5 = '2abc'

print(str5.isidentifier())  # False,不能以数字开头

str6 = 'apple'

print(str6.isidentifier())  # True

 isalpha 判断是否全部为字母

print(str6.isalpha())  # True

 isalpha   默认将中文当做字母来看

print(str7.isalpha())  # True

encode   如果强制判断字母和汉字区分开(了解即可)

print(str7.encode('utf-8').isalpha())  # False
print(str6.encode('utf-8').isalpha())  # True

 16.列表的定义

列表定义的格式: 变量名 = [数据1, 数据2 ,,,,,,,]

# 注意:在Python中 列表可以储存不同数据类型的数据
# 但是 在开发中,为了方便使用和后期迭代,数组中一般储存同种数据类型数据

name_list = ['Rose', 'Jack', 'Tom']

print(name_list) # ['Rose', 'Jack', 'Tom']

 16.1 列表的查询

索引查询

结论: 列表中的索引和字符串中完全一致,

name_list = ['Bob', 'Jack', 'Rose']

print(name_list[0])  # Bob

index  查询指定元素在列表中的索引,如果查询成功则返回该元素的正向索引,否则报错

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 5]

print(num_list.index(5))  # 4

 count  计数

print(num_list.count(5))  # 2

in 和not  判断数据元素是否在列表内  如果在  True  不在False

print(5 in num_list)  # True

print(5 not in num_list)  # False

 16.2 列表的增加

append   在列表后追加数据

# list类型在使用append 方法时不会产生新的列表,而是在原有列表上进行修改

# 如果直接打印append方法的调用,将不会输出任何内容

num_list = [1, 2, 3, 4]
num_list.append(5)
print(num_list)  # [1, 2, 3, 4, 5]

extend  追加数据序列
# 格式: 列表1.extend(数据序列)

# 追加字符串序列时,会将字母依次拆分并放入列表中

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # [1, 2, 3, 4, 5, 6]
print(list2)  # [4, 5, 6]
str1 = 'itcast'
list2.extend(str1)
print(list2)  # [4, 5, 6, 'i', 't', 'c', 'a', 's', 't']

insert 插入

格式:列表.insert(要插入位置的索引, 要插入的对象)

# 在开发中除非明确所有的索引引用都修改完成,否则不要使用insert

# 如果使用insert进行 插入,可能会造成索引混乱,原来引用的索引发生错误

# 在insert中第一个参数是要插入位置的索引,所以如果插入了数,则该被插入数据的索引变为第一参数所显示的索引

num_list = [1, 2, 3, 4]
num_list.insert(1, 5)
print(num_list)   #[1, 5, 2, 3, 4]

extend 和append 进行对比

list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
# append将list2 当做一个元素追加到列表末尾
# list1.append(list2)  # [1, 2, 3, 4, [5, 6, 7, 8]]
# extend将list2 当做多个元素进行拆分后追加
list1.extend(list2)  # [1, 2, 3, 4, 5, 6, 7, 8]
print(list1)

16.3 列表的删除

del   删除

通过索引获取当前元素,并删除，无返回值

删除的内容不存在会报错

list1 = [1, 2, 3, 4]
del list1[2]
print(list1)  # [1, 2, 4]

pop  删除指定索引的元素,并且返回该元素

# 删除后,指定索引位置的元素消失后边的元素统一向左移动一位
# pop也会造成索引变换，索引不存在会报错

list1 = [1, 2, 3, 4]
print(list.pop(1))  #2
# 如果不给pop进行传值,默认删除最后一个元素
print(list1.pop())

remove 删除指定的元素(从左至右第一次出现的元素)，无返回值

# 若删除的内容不存在则会报错

list1 = [1, 2, 3, 3, 4, 2, 1]
list1.remove(2)
print(list1)  # [1, 3, 3, 4, 2, 1]

clear  清空列表

list1.clear()

print(list1)  # []

 16.4 列表的修改

通过索引进行修改

# 获取的元素位置,必须是存在的

list1 = [1, 2, 3, 4]
list1[1] = 6

# 可以使用对多变量赋值的形式修改多个值

list1[2], list1[3] = 6, 7

 reverse  列表的反转

# 列表反转后,索引倒置,并且在原数据上修改,没有产生新的列表

print(list1.reverse())  # None
print(list1)  # [4, 3, 2, 1]

 sort  排序

# sort是对原有的数据进行了排序,没有产生新的列表.同时,默认排序规则为升序

list2 = [2, 6, 43, 2, 41, 421]

print(list2.sort())  # None
print(list2)  # [2, 2, 6, 41, 43, 421]

# 如果我想让列表降序排列怎么办?
# 方法一:可以先排序再反转
# list2.sort()
# list2.reverse()
# print(list2)  # [421, 43, 41, 6, 2, 2]
# 方法二: 可以直接使用倒叙排列
# list2.sort(reverse=True)  # [421, 43, 41, 6, 2, 2]
# print(list2)

# list2.sort(key=排序规则函数)可以帮助我们进行更加复杂的排序
# 根据每个元素 % 7 的余数大小进行排序
# 了解, 不要求掌握 后续会讲
list2.sort(key=lambda x: x % 7)
print(list2)

 16.5 列表的遍历

while 遍历列表

# len()函数可以查询列表的长度

list1 = [12, 123, 1, 1, 1234, 12, 34, 8]
# print(len(list1))
i = 0
while i < len(list1):
    print(list1[i])
    i += 1

for 遍历列表
# 推荐使用for循环遍历容器类型(数据序列)

for i in list1:
    print(i)

# 这种方法有多少个5就循环多少次
for i in range(list1.count(5)):
    list1.remove(5)
# 使用pop删除
for i in range(list1.count(5)):
    index_1 = list1.index(5)
    list1.pop(index_1)
print(list1)
# 使用del删除
for i in range(list1.count(5)):
    index_1 = list1.index(5)
    del list1[index_1]
print(list1)

 16.6 列表的嵌套

列表的嵌套: 在一个列表中包含其他的列表元素

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
# 需求:想要获取李四的值
# 获取李四所在的子列表的索引,并通过索引获取该子列表值
print(name_list[2])
# 再从子列表中通过李四所在的索引获取其值
print(name_list[2][1])
for i in name_list:
    print(i)
# 如果想要对嵌套后的列表进行输出,需要进行循环嵌套
for sub_list in name_list:
    for name in sub_list:
        print(name)
# 如果当前的列表内的数据不都是子列表,有其他数据类型的数据,则不能直接使用循环嵌套,需要先进行类型判断

17.元祖

元组:可以储存多个数据,但是元组内的数据不能被修改(元定义后只能被查询)

元组的定义:变量 = (数据1, 数据2, 数据3......)

tuple4 = (10,)
print(type(tuple4))  # <class 'tuple'>
# 在定义元素或者传值时,元组的括号可以省略
tuple6 = 5,
print(tuple6)  # (5,)

元祖只能查询，统计

tuple1 = (1, 2, 3, 4, 3)
print(tuple1[-2]) # 4
print(tuple1.index(3))  # 2
print(tuple1.count(3))  # 2
print(len(tuple1))  # 5
print(tuple1.__len__())  # 5

18.字典

# 字典:储存多个数据,以键值对形式存储,方便快速存取

# 定义字典时 ,不能有重复的键,否则后定义的键值对会覆盖先定义的

# 字典定义格式: 变量 = {键1:值1, 键2:值2.....}

dict1 = {'name': 'xiaoming', 'age': 18, 'gender': '女'}
dict2 = {}    # 定义空字典
dict3 = dict()    # 定义空字典

18.1字典的增加

格式:字典变量[key] = 值

如果原字典中存在该key 则为修改原key所对应的值

如果update中添加的键已经存在则修改原有的值

dict1 = {'name':'xiaoming', 'age': 18}
dict1['gender'] = '男'
dict1.update({'id': '001', 'color': 'yellow', 'name': 'rose'})

18.2字典的删除

del   删除

dict1 = {'name': 'xiaoming', 'age': 18}
del dict1['age']
print(dict1)  # {'name': 'xiaoming'}

clear() 清空字典

dict1.clear()
print(dict1)  # {}

pop  删除

# 使用pop删除键值对后会将其键对应的值进行返回

#pop删除是无序的，因为不能通过索引进行键值对的获取

dict2 = {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# print(dict2.pop('name'))  # xiaoming
# print(dict2)  # {'age': 18, 'gender': '男'}
# 猜测:popitem也是删除键值对使用的
# 随机删除一个键值对,一般都是删除最后一个
# 删除后会将我们所删除的键值对以元组的形式进行返回
print(dict2.popitem())  # ('gender', '男')
print(dict2.popitem())  # ('age', 18)
print(dict2)  # {'name': 'xiaoming'}

18.3字典的修改

1.通过键值对修改

2.通过update修改

dict1 = {'name':'小明', 'age':18}
dict1['name'] = '小红'
print(dict1)
dict1.update({'name': '小绿'})
print(dict1)

18.4字典的查询

1.通过key进行查询

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1['name'])

2.get  查询

如果使用get查询的键不存在,则不会报错,会默认返回一个None，也可以赋默认值

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1.get('name'))  # 小明
print(dict1.get('apple'))  # None
# 格式 字典.get(要查询的键, 查询的键不存在时返回的数据)
print(dict1.get('apple', '小刚'))
print(dict1.get('apple', 9))

3.keys  获取当前字典中所有的键

keys返回的内容不是列表,而是dict_keys,该数据类型不能直接使用索引查询数据,但是可以进行for遍历

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender', 'id'])
print(type(dict1.keys()))  # <class 'dict_keys'>
keys_1 = dict1.keys()
#  不能使用索引查询
# 可以被迭代
for i in keys_1:
    print(i)    # name age gender id

4.values 获取当前字典中所有的值

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1.values())  # dict_values(['小明', 18, '男', '001'])
# dict_values不能使用索引查询,但是可以迭代
print(type(dict1.values()))  # <class 'dict_values'>

5.items  获取当前字典中所有的键值对，键值对以元祖形式展示

dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
print(dict1.items())  # dict_items([('name', '小明'), ('age', 18), ('gender', '男'), ('id', '001')])
# dict_items不能使用索引查询,但是可以迭代
print(type(dict1.items()))  # <class 'dict_items'>

18.5字典的遍历

# 字典的遍历
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
# 使用for循环对字典进行遍历,默认获取的是字典的每一个键
for i in dict1:
    print(i)
# 获取的是字典的每一个键
for i in dict1.keys():
    print(i)
# 获取的是字典的每一个值
for i in dict1.values():
    print(i)
# 获取的是字典中每一个键值对组成的元组
for i in dict1.items():
    print(i)

# 有没有办法可以分别拿到字典的键和值呢?
for i in dict1:
    print(i, dict1[i])
for key, value in dict1.items():
    print(key, value )

19.集合

19.1集合的定义

# 集合: 集合是一个无序,不重复的数据序列
# 无序: 程序员无法控制其排不顺序,  程序员无法使用索引查找或修改数据
# 不重复:没有办法在字典中放入相同的值,会自动去重,类似于字典的键

了解:在集合中会使用数据的值计算哈希值,根据哈希值顺序进行排序

set会自动去重

# 基础数据类型 int  float  bool  字符串 都可以用集合储存
set4 = {1, 12.3, True, 0, False, ''}
print(set4)

# 列表数据无法用集合储存

# 元组类型可以放入集合内储存
set6 = {1, 12.3, True, 0, False, '', (1, 2)}
print(set6)

 19.2集合的添加

1.add  添加

2.update  添加

# add 增加
set1 = {1, 2, 3, 4}
# set 在使用add命令后,不会产生新的数据,而是原集合中进行修改
set1.add(5)
print(set1)  # {1, 2, 3, 4, 5}

# update 更新
# TypeError: 'int' object is not iterable
# update内部只能填写容器类型(数据序列)
# set1.update(6)
set1.update([6, 7])
print(set1)  # {1, 2, 3, 4, 5, 6, 7}
# 如果更新的数据已经存在,则去重
set1.update([1,2])
print(set1)  # {1, 2, 3, 4, 5, 6, 7}

19.3集合的删除

1.remove  删除

2.pop  删除

3.discard  删除

# remove
set1 = {1, 2, 3, 4}
# 使用remove可以删除指定值的元素
# set1.remove(3)
# print(set1)  # {1, 2, 4}

# pop 随机删除一个元素,并且将删除的元素返回
# print(set1.pop())
# print(set1)

# discard
# 如果使用remove删除的元素不存在会怎样?  报错
# set1.remove(13)  # KeyError: 13
# 如果使用discard删除元素呢?  不会报错
set1.discard(3)
print(set1)  # {1, 2, 4}
set1.discard(13)
print(set1)

19.4数据是否在集合中  in / not in

set1 = {1, 2, 3, 4}
print(4 in set1)  # True
print(4 not in set1)  # False

19.5集合的遍历

# 注意遍历集合,顺序不定
name_set = {'Tom', 'Bob', 'Rose'}
for i in name_set:
    print(i)