【自动化测试基础】一、python基础知识

原创已于 2023-01-30 11:12:25 修改 · 1.3k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#python

于 2022-03-26 15:31:56 首次发布

python 同时被 2 个专栏收录

12 篇文章

订阅专栏

软件测试

6 篇文章

订阅专栏

下一篇：二、python高级知识

文章目录

一、变量的使用
二、注释
三、运算符
四、命名规则
五、查看python里面有哪些保留字
六、六大数据类型
七、常用函数
- type()函数：查看数据类型
- input()函数：用来做控制台输入，可以接收控制台输入的内容
八、其他
九、if条件判断：分支结构
十、循环

一、变量的使用

1. 变量的声明

1.1 全局变量：global

1、global是Python中的全局变量关键字。
2、全局变量是编程术语中的一种，源自于变量之分。
3、变量分为局部与全局，局部变量又可称之为内部变量。
4、由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
5、全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
6、global关键字的作用是可以使得一个局部变量为全局变量。
（原文链接：https://blog.youkuaiyun.com/hzblucky1314/article/details/122724678）

def get_info():
    global name
    name = "jingjing"


if __name__ == '__main__':
    get_info()  # 注意这边需要先执行get_info()方法。
    print("我的名字是：" + name)

# 数组的个数为：5

1.2 非局部变量：nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

    非局部声明变量指代的已有标识符是最近外面函数的已声明变量，但是不包括全局变量。这个是很重要的，因为绑定的默认行为是首先搜索本地命名空间。nonlocal声明的变量只对局部起作用，离开封装函数，那么该变量就无效。非局部声明不像全局声明，我们必须在封装函数前面事先声明该变量。非局部声明不能与局部范围的声明冲突。

（原文链接：https://blog.youkuaiyun.com/qq_51408776/article/details/114834856）

如果未声明直接使用会报错：UnboundLocalError: local variable 'num' referenced before assignment

def test1():
    num = 2
    print(num)  # 2

    def test2():
        nonlocal num  # 如果未声明直接使用会报错
        # 内层函数未定义此变量num 通过关键字nonlocal，直接使用此变量
        print(num)  # 2 
        num = 3
        print(num)  # 3

    test2()
    print(num)  # 3 # 内层函数对变量的改变 会作用到外层


test1()
# 2
# 2
# 3
# 3

2. 赋值

3. 覆盖

变量可以一次声明，多次赋值，前面的赋值会被后面的赋值覆盖

python 是严格区分大小写

二、注释

提示：多行注释快捷键：ctrl+/

# 这个是单行注释 

"""这个也是注释"""

'''这个还是注释'''

三、运算符

浮点数不管做什么运算，结果一定是浮点数
除法运算的值也是浮点型

1.算术运算符

1.1 四则运算：+、-、/、*

1.2 取余运算：%

所有奇数对2取余都是1，所有偶数对2取余都是0，所有小数对大数取余都是小

1.3 取整运算：//

向下取整
-8//3 -3

1.4 幂等：**

2.赋值运算符：=、-=、 +=、*=、/=、//=、%=、**=

3.比较运算符：>、<、>=、<=、!=、==

结果只能是True False

4.逻辑运算符

4.1 and：全真为真

4.2 or：全假为假

4.3 not：取反

bo1=10>20   
print(not(bo1))     # True

5.成员运算符

in 、 not in

6.身份运算符

is：判断2个标识符是否为同一对象，比较存储地址

not is

7.IS 和 == 的区别

is：是用来判断两个变量是否引用同一物理地址
==：用来判断变量值是否相等

四、命名规则

变量名由大小写英文字母、数字和下划线_组成
变量名不能用数字开头
python 的关键字不能用做变量名

五、查看python里面有哪些保留字

import   keyword
print（keyword.kwlist）
"""
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
  'try', 'while', 'with', 'yield']
 """

六、六大数据类型

1.数字类型

1.1 整数 int

包含正整数、负整数。
布尔是整数的子类型。

a=1
print(type(a))
# <class 'int'>

1.2 浮点数 float

包含整数、小数

1.3 复数 complex

复数是由实数部分和虚数部分组成，可以用a+bj，或者complex（a,b）表示，复数的实部a和虚部b都是浮点数

1.4 布尔值 bool

布尔是整数的子类型。

True、Flase

成立，为真
不成立，为假

print(type(True))
# <class 'bool'>

print(bool(0))
# False

print(bool(1+1))
# True

2.字符串类型 string

由单引号或者双引号括起来的字符
字符串中的单引号和双引号可以配合使用

2.1 字符串的声明和赋值：’ '、" "

a="今天天气好好呀"
print(a) # 今天天气好好呀

字符串过长通过回车进行换行，输出结果还是一行

b='今天天' \
  '气好好呀'
print(b) # 今天天气好好呀

三引号，自动取消所有编译，原样输出‘str’

print("""1+2""")
# 1+2

c="""今
天
天
气
好
好
呀"""
print(c)    # 今
            # 天
            # 天
            # 气
            # 好
            # 好
            # 呀
"""声明变量不赋值"""
a=str()      
a=bool()     
a=int()      
a=float()

2.2 常用运算符

2.2.1 +：拼接字符串

提示：数字和字符串不能相加，会报错

a = "今天"
b = a + "天气好好呀"
print(b)  # 今天天气好好呀

2.2.2 *：复制字符串

a = "今天"
print(a * 5)  # 今天今天今天今天今天

2.2.3 in：判断字符串元素是否存在

a = "今天天气好好呀"
print("今天" in a)  # True

2.2.4 ：：字符串索引

字符串对每个字符都做了编号（下标），从前往后数从0开始，从后往前数从-1开始

str6='abcdefg'   
print(str6[0]) # a

2.2.5 反转输出

a = 'hello  world'
print(a[::-1])  # dlrow  olleh

2.2.6 字符串的切片

str = 'abcdefg'
print(str[0:5])  # abcde

str = 'abcdefghijklmnopq'
print(str[1:5:2])  # bd #2代表步长

2.2.7 字符串转义

符号	解释
\n	换行符
\t	制表符，相当于一个Tab键
r/R	加在字符串前面，取消转义，原样输出

'''\t'''
str = 'abcdefg\thijklmnopq'
print(str)  # abcdefg	hijklmnopq

'''\n'''
str = 'abcdefg\nhijklmnopq'
print(str)  # abcdefg
            # hijklmnopq

2.3 常用方法

2.3.1 .join（str）拼接

使用括号内str拼接join前的元素
提示：括号中的内容必须是字符串

str1 = '-'
a = ['2022', '03', '29']
print(str1.join(a))  # 2022-03-29
print(type(str1.join(a)))  # <class 'str'>

2.3.2 str.find(str, beg=0, end=len(string))：查找元素第一次出现的索引位置

提示：如果包含子字符串返回开始的索引值，否则返回-1。

str = 'abcdefghijklmnopq'
print(str.find("d"))  # 3

2.3.3 str.replace(str1,str2)：替换

查找字符串中所有的元素，将字符串str1替换成str2；如果str1不存在，直接输出原字符串，替换后，物理地址改变

''' 去除字符串中的空格·'''
str = 'ab cdefg hijkl mn opq'
print(str.replace(" ",""))  # abcdefghijklmnopq

2.3.4 str.count()：统计元素在字符串中出现的次数

当被统计字符不存在时，返回0

''' 去除字符串中的空格·'''
str = 'ab cdefg hijkl mn opq'
print(str.count(" "))  # 4

2.3.5 str.upper（）：转换成大写

str = 'ab cdefg hijkl mn opq'
print(str.upper())  # AB CDEFG HIJKL MN OPQ

2.3.6 str.lower（）：转换成小写

str = 'AB CDEFG HIJKL MN OPQ'
print(str.lower())  # ab cdefg hijkl mn opq

2.3.7 len（）：求字符串的长度

str = 'AB CDEFG HIJKL MN OPQ'
print(len(str))  # 21

2.3.8 str.isnumeric（）：判断字符串中的元素是否为纯数字

是：True 否：False

str = '1'
print(str.isnumeric())  # True

str = "abcdefg"
print(str.isnumeric())  # False

2.3.9 str.format()：格式化输出

2.3.9.1 str{}.format(str)：其基本语法是通过{}来代替以前的%其基本语法是通过{}来代替以前的%

print("你好，我的名字叫{}".format("静静"))  # 你好，我的名字叫静静

print("{}，我的名字叫{}".format("你好", "静静"))  # 你好，我的名字叫静静

"""通过下标进行填充"""
print("{0}，我的名字叫{1}".format("你好", "静静"))  # 你好，我的名字叫静静
print("{1}的{1}叫什么，{1}的{1}叫{0}".format("爷爷", "爸爸"))  # 爸爸的爸爸叫什么，爸爸的爸爸叫爷爷

"""通过参数进行填充  """
print("{a}，我的名字叫{b}".format(a="你好", b="静静"))  # 你好，我的名字叫静静

"""传统填充方式  %s  %d   %f     %"""
str31 = '小红来自%s,年龄%d,年收入%f万'
str32 = str31 % ('江苏', 18, 12.888888888)
print('小刘来自%s,目前工资%.2f,年龄%d' % ('西安', 99.9999, 35))  # 小刘来自西安,目前工资100.00,年龄35

2.3.9.2 str{:.nf}.format(float)：保留n位小数

str25 = '小花来自{}，年龄{}，目前薪资{:.3f}万'
str26 = str25.format('上海', 18, 0.554556)
print(str26)  # 小刘来自江苏，年龄18，目前薪资0.555万

num1 = float(input("请输入第一个数字:"))
num2 = float(input("请输入第二个数字:"))
print("{}加上{}等于{:.2f}".format(num1, num2, num1 + num2))

# 请输入第一个数字:2.33
# 请输入第二个数字:44.44
# 2.33加上44.44等于46.77
# 进程已结束,退出代码0

2.字符串和数字、布尔类型相互转换

提示：类型的强制转换可能会造成精度丢失
提示：大类转小类，精度丢失

2.1数字类型转字符串类型

@ TODO

2.2字符串类型转数字类型

提示：保证值为数字才可以转换

@ TODO

2.3 字符串转布尔（bool）类型

@ TODO

3.元组类型 Tuple

不可变类型，创建后不能修改数据；任意无符号的对象，以逗号隔开，默认为元组；主要符号逗号，有序

3.1 创建元组

tuple=() #创建空元素
print(type(tuple)) # <class 'tuple'>

tuple=(1,) #创建单个元素
print(tuple) # 1
print(type(tuple)) # <class 'tuple'>

tup1 = ('1', '2', 1, 2) #创建多个元素
print(tup1)  # ('1', '2', 1, 2)
print(type(tup1))  # <class 'tuple'>

3.2 修改元组变量

提示：元组中的元素不可以修改，但是元组可以重新被赋值

tup1 = ('1', '2', 1, 1, 2)
tup1 = (2,2,2,2,2)
print(tup1)  # (2,2,2,2,2)
print(type(tup1))  # <class 'tuple'>

3.3 遍历元组

tup1 = ('1', '2', 1, 1, 2)
for i in tup1:
    print(i,end=" ")
    print(type(i)) 	# 1 <class 'str'>
					# 2 <class 'str'>
					# 1 <class 'int'>
					# 1 <class 'int'>
					# 2 <class 'int'>

3.4 len()：计算元素个数

tup1 = ('1', '2', 1, 1, 2)
print(len(tup1)) # 5

3.5 通过下标查找元素

tup1=('xiaohua',2,(1,2,3),[7,5,6,'ajhgafjdhgjadhgajhgf'])
print(tup1[-1][3][-3])  # h
print(tup1[2])  # (1, 2, 3)

3.6 常用运算符

3.6.1 +：拼接元组

tuple = (3,)
tup1 = tuple + ('1', '2', 1, 1, 2)
print(tup1) # (3, '1', '2', 1, 1, 2)
print(type(tup1)) # <class 'tuple'>

3.6.2 *：复制元组

tuple = (3, 1)
print(tuple * 3)  # (3, 1, 3, 1, 3, 1)

3.6.3 in：判断元组中的元素是否存在

tuple = (3, 1)
print(3 in tuple)  # True

3.6.4 ：：读取第n个元素（元组切片）

"""读取单个元素"""
tuple = (3, 1)
print(tuple[0])  # 3

"""读取多个元素"""
tuple = (3, 14, 5, 7, 23, 45, 66, 64, 23)
print(tuple[:3])  # (3, 14, 5)
print(tuple[2:5]) # (5, 7, 23)
print(type(tuple[:3]))  # <class 'tuple'>

3.7 常用方法

3.7.1 .index()：通过元素查找下标位置

tup1=("a","jj",99)
tuple= tup1.index("a")
print(tuple) # 0

T = ('Google', 'Runoob', 'Taobao')
print(T.index('Taobao')) # 2

3.7.2 .count()：统计元素出现的次数

tuple = (1, 1, 1, 2, 2, 2, 3)
print(tuple.count(1))  # 3

3.7.3 .title()：首字母大写

username = "sarah"
print(f"hello,{username.title()}.")  # hello,Sarah.

4.列表类型 List

由”[ ]“组成，元素之间用”，“分隔。元素可以修改。

4.1 创建列表

'''创建空列表'''
list1 = []
print(list1)  # []
print(type(list1))  # <class 'list'>

'''创建单个列表'''
list1 = [3]
print(list1)  # [3]
print(type(list1))

'''创建多个列表'''
list1 = ['1', '2', 1, 1, 2]
print(list1)  # ['1', '2', 1, 1, 2]
print(type(list1))

4.2 修改列表的元素

'''修改列表元素'''
list1 = [3, 14, 5, 7, 23, 45, 66, 64, 23]
list1[0]=99
print(list1)  # [99, 14, 5, 7, 23, 45, 66, 64, 23]
print(type(list1))

'''修改列表元素为列表'''
list1 = [3, 14, 5, 7, 23, 45, 66, 64, 23]
list1[0]=["哈哈"]
print(list1)  # [['哈哈'], 14, 5, 7, 23, 45, 66, 64, 23]
print(type(list1))

list1=[['哈哈','嘻嘻'], [14, 5, 7, 23], 45, 66, 64, 23]
list1[0][1]=99
print(list1)  # [['哈哈', 99], [14, 5, 7, 23], 45, 66, 64, 23]
print(type(list1))

4.3 遍历列表

遍历非嵌套列表

list1=[14, 5, 7, 23]

for j in list1:
	print(j)
    
# 14
# 5
# 7
# 23

遍历嵌套列表

list1=[['哈哈','嘻嘻'], [14, 5, 7, 23]]

print("===方法一===")
for i in range(0,len(list1)):
    for j in range(0,len(list1[i])):
        print(list1[i][j])

print("===方法二===")
for i in list1:
    for j in i:
        print(j)
# 哈哈
# 嘻嘻
# 14
# 5
# 7
# 23

4.4 计算元素个数 len()

提示：只计算末级列表的元素个数

list1=[['哈哈','嘻嘻'], [14, 5, 7, 23]]
print(len(list1)) # 2

list2=['哈哈','嘻嘻', 14, 5, 7, 23]
print(len(list2)) # 6

list1=[['哈哈','嘻嘻'], [14, 5, 7, 23]]
print(len(list1[1])) # 6

4.5 常用运算符

4.5.1 +：拼接列表

list1 = [['哈哈', '嘻嘻'], [14, 5, 7, 23]]
list2 = list1 + [['哈哈', '嘻嘻'], [14, 5, 7, 23]]
print(list2)  # [['哈哈', '嘻嘻'], [14, 5, 7, 23], ['哈哈', '嘻嘻'], [14, 5, 7, 23]]

4.5.2 *：复制列表

list1 = ['哈哈', '嘻嘻']
print(list1*3)  # ['哈哈', '嘻嘻', '哈哈', '嘻嘻', '哈哈', '嘻嘻']

4.5.2 i：判断列表中的元素是否存在

提示：不能再嵌套列表里面判断

list1 = [[["哈哈哈哈","哈哈哈","哈哈","哈"],["嘻嘻嘻嘻","嘻嘻嘻","嘻嘻"]], [14, 5, 7, 23],99]
print(99 in list1)  # True
print("嘻嘻嘻嘻" in list1) # False 只能在子元素里判断，不能再子列表里面判断
print("嘻嘻嘻嘻" in list1[0][1]) # True

4.5.2 ：：读取第n个元素

"""读取单个元素"""
list1 = ["哈哈哈哈","哈哈哈","哈哈","哈"]
print(list1[0])  # 哈哈哈哈
print(type(list1[0])) # <class 'str'>

"""读取多个元素"""
list1 = ["哈哈哈哈","哈哈哈","哈哈","哈","嘻嘻嘻嘻","嘻嘻嘻","嘻嘻", [14, 5, 7, 23],99]
print(list1[6:])  # ['嘻嘻', [14, 5, 7, 23], 99]
print(list1 [2:5]) # ['哈哈', '哈', '嘻嘻嘻嘻'] # 左包含，右不包含

4.6 常用方法

4.6.1 .append(obj) ：再列表末尾添加新的对象

list1 = ["哈哈哈哈"]
list1.append("哈哈哈")
print(list1) # ['哈哈哈哈', '哈哈哈']

4.6.2 .count(obj)：统计某个元素再列表中出现的次数

list1 = ["哈哈哈哈","哈哈哈","哈哈","哈","嘻嘻嘻嘻","嘻嘻嘻","嘻嘻", [14, 5, 7, 23],99]
print(list1.count("哈")) # 1

4.6.3 .index()：从列表里面找出相匹配的值的第一个索引

list1 = [[["哈哈哈哈","哈哈哈","哈哈","哈"],["嘻嘻嘻嘻","嘻嘻嘻","嘻嘻"]], [14, 5, 7, 23],99]
print(list1[0][0].index("哈")) # 3

4.6.4 .insert(索引位置，obj)：在索引位置插入列表、元素

list1 = [["嘻嘻嘻嘻","嘻嘻嘻","嘻嘻"], [14, 5, 7, 23],99]
list1.insert(0,["哈哈哈哈"])
print(list1) # [['哈哈哈哈'], ['嘻嘻嘻嘻', '嘻嘻嘻', '嘻嘻'], [14, 5, 7, 23], 99]

4.6.5 .pop(索引位置)：删除最后一个元素

提示：索引位置为空时，默认删除最后一位

list1 = [["嘻嘻嘻嘻","嘻嘻嘻","嘻嘻"], [14, 5, 7, 23],99]
list1.pop(0)
print(list1) # [[14, 5, 7, 23], 99]

4.6.6 .reverse()：反转列表元素

list1 = [["嘻嘻嘻嘻","嘻嘻嘻","嘻嘻"], [14, 5, 7, 23],99]
list1.reverse()
print(list1) # [99, [14, 5, 7, 23], ['嘻嘻嘻嘻', '嘻嘻嘻', '嘻嘻']]

4.6.7 .sort()：列表排序

"""降序排序"""
list1 = [14, 5, 7, 23, 99]
list1.sort(reverse=True)
print(list1)  # [99, 23, 14, 7, 5]

"""升序排序"""
list1 = [14, 5, 7, 23, 99]
list1.sort()
print(list1)  # [99, 23, 14, 7, 5]

4.6.8 .clear()：清空列表

list1 = [14, 5, 7, 23, 99]
list1.clear()
print(list1)  # []

4.6.9 .copy()：复制列表

list1 = [14, 5, 7, 23, 99]
list2=list1.copy()
print(list2)  # [14, 5, 7, 23, 99]

5.字典类型 Dictionary

字典则是通过名字来引用值的数据结构，并且把这种数据结构称为映射，字典中的值没有特殊的顺序，都存储在一个特定的键（key）下，字典的key必须是不可变类型（数字、字符串、元组），value可以是任意类型。键必须是唯一的，但是值可以不是

5.1 创建字典

dict1={}
dict2=dict()

5.2 通过key获取value

dict = {"name": "jingjing", "age": 18}
print(dict['name'])  # jingjing

print(dict.get('name'))  # jingjing

5.3 修改字典的元素

dict1 = {"name": "jingjing", "age": 18}
dict1["age"] = 19
print(dict1)  # {'name': 'jingjing', 'age': 19}

5.4 增加单个键值对

dict = {"name": "jingjing", "age": 18}
dict['class'] = '20班'
print(dict)  # {'name': 'jingjing', 'age': 18, 'class': '20班'}

5.5 增加多个键值对

dict = {"name": "jingjing", "age": 18}
dict.update({'id': 100, 'phone': 110})
print(dict)  # {'name': 'jingjing', 'age': 18, 'id': 100, 'phone': 110}

5.6 转换成有序

dict7 = {'name': 'jingjing', 'age': 18, 'sex': '女'}
kvs = dict7.items()
list2 = list(kvs)  # list2=[('name', 'jingjing'), ('age', 18), ('sex', '女')]
print(list2[0])  # ('name', 'jingjing')
print(list2[0][1])  # jingjing

5.7 常用方法

5.7.1 .key() ：获取所有key

dict7 = {'name': 'jingjing', 'age': 18, 'sex': '女'}
ks = dict7.keys()
print(ks)  # dict_keys(['name', 'age', 'sex'])
print(type(ks))  # <class 'dict_keys'>

5.7.2 .value()：获取所有value

dict7 = {'name': 'jingjing', 'age': 18, 'sex': '女'}
vs = dict7.values()
print(vs)  # dict_values(['jingjing', 18, '女'])
print(type(vs))  # <class 'dict_values'>

5.7.3 .items()：获取键值对

dict7 = {'name': 'jingjing', 'age': 18, 'sex': '女'}
kvs = dict7.items()
print(list(kvs))  # [('name', 'jingjing'), ('age', 18), ('sex', '女')]
print(type(kvs))  # <class 'dict_items'>

5.7.5 .pop(key)：根据key，删除key-value

dict = {"name": "jingjing", "age": 18}
dict.pop("age")
print(dict)  # {'name': 'jingjing'}

5.7.8 .clear()：清空字典

dict = {"name": "jingjing", "age": 18}
dict.clear()
print(dict)  # {}

5.7.9 .copy()：复制字典

dict1 = {}
dict2 = dict.copy()
print(dict1)  # {}

6.集合类型 Set

无序、没有索引（下标），不能重复，只能存放不可变类型的元素列表不能存放其中

6.1 创建集合

set1 = {11, 22, 33, 44}
print(set1)  # {33, 11, 44, 22}
print(type(set1))  # <class 'set'>

6.2 set()：字符串、列表、元组转换成集合（自动去重）

# 定义list变量
list = ["h","e","l","l","o"]
# 使用set()函数
s1 = set(list)
print("set(list):", s1)  # set(list): {'o', 'l', 'e', 'h'}
print(type(s1))  # <class 'set'>

# 定义tuple变量
tuple = ("h","e","l","l","o")
# 使用set()函数
s2 = set(tuple)
print("set(tuple):", s2)  # set(tuple): {'o', 'l', 'e', 'h'}
print(type(s2))  # <class 'set'>

# 定义dict变量
dict = {'name': 'jingjing', 'age': 18}
# 使用set()函数
s3 = set(dict)
print("set(dict):", s3)  # set(dict): {'name', 'age'}
print(type(s3))  # <class 'set'>

6.3 遍历集合
6.4 计算元素个数 len()
6.5 常用运算符
6.6.1 +：拼接集合
6.6.2 *：复制集合
6.6.2 i：判断集合中的元素是否存在
6.6.2 ：：读取第n个元素

6.6 常用方法

6.6.1 .append(obj) ：再集合末尾添加新的对象
6.6.2 .count(obj)：统计某个元素再集合中出现的次数
6.6.3 .index()：从集合里面找出相匹配的值的第一个索引

6.6.1 .add()：添加单个元素

set1 = {11, 22, 33, 44}
set2=set1.add(88)
print(set1)  # {33, 11, 44, 22, 88}

6.6.2 .add()：添加多个元素

s1 = set('jingjing')
s1.update('你好')
print(s1)  # {'你', '好', 'g', 'n', 'i', 'j'}
s1.update('nihao')
print(s1)  # {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}

6.6.3 .remove(元素)：删除元素并输出（元素不存在会报错）

set = {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}
set.remove("j")  # {'a', 'n', '你', 'h', '好', 'i', 'o', 'g'}
print(set)
set.remove("x")
print(set)  # KeyError: 'x'

6.6.4 .discard(元素)：删除元素（元素不存在不会报错）

set = {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}
set.discard("j")  # {'a', 'n', '你', 'h', '好', 'i', 'o', 'g'}
print(set)  # {'n', '好', '你', 'g', 'h', 'i', 'o', 'a'}
set.discard("x")
print(set)  # {'n', '好', '你', 'g', 'h', 'i', 'o', 'a'}

6.6.7 .sort()：集合排序

6.6.5 .clear()：清空集合

set = {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}
set.clear()
print(set)  # set()#为什么不是{}，因为被字典占用

6.6.6 .copy()：复制集合

set = {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}
set1 = set.copy()
print(set1)  # {'h', 'g', 'j', 'i', '你', 'a', 'o', 'n', '好'}

6.6.7 删除集合

set1 = {'j', 'g', 'a', 'h', '好', '你', 'o', 'i', 'n'}
print(set1)
del set1
print(set1)  # ameError: name 'set1' is not defined

6.6.8 .intersectiong()：交集， `交集元素，取相同值`

"""交集元素，取相同值"""
set1 = {1, 2, 3}
set2 = {2, 3, 4}
set3 = set1.intersection(set2)
print(set3)  # {2, 3}

6.6.9 .union()：并集，`并集集合，去重后全值`

"""并集集合，去重后全值"""
set1 = {1, 2, 3}
set2 = {2, 3, 4}
set3 = set1.union(set2)
print(set3)  # {1, 2, 3, 4}

数据类型总结

在这里插入图片描述

可变类型：可修改数据的内容

不可变：不可修改数据的数据的内容

空值 None

print(type(None))
# <class 'NoneType'>

print(type(0))
# <class 'int'>

七、常用函数

type()函数：查看数据类型

a=3
print ('a的数据类型是：'，type(a))

提示：类型的强制转换可能会造成精度丢失
提示：大类转小类，精度丢失
提示：除了0、0.0外，其余所有的整数、浮点数类型转换成bool类型都是True，非0为真

input()函数：用来做控制台输入，可以接收控制台输入的内容

提示：所有从控台输入的内容都是字符串格式

'''	设计一个简单的整数加法计算器'''
a= int(input("请输入第一个数字："))
b= int(input("请输入第二个数字："))
print("两个数字相加之和为：%s"%(a*b))

八、其他

1.深拷贝、浅拷贝、赋值

1.1 浅拷贝：

浅拷贝物理地址不一样
可变类型元素的引用物理地址
可变类型中的元素改变
拷贝值改变

不可变类型的元素改变
拷贝值不变

1.2 深拷贝

深拷贝物理地址不一样
可变类型中的元素变化
拷贝值不变

不可变类型中的元素变化
拷贝值不变化
在这里插入图片描述
*图片为引用，原作者不详

2. 拆包、组包

组包: 将多个值同时赋给一个变量时,解释器会进行自动组包操作
拆包: 将一个容器值(元组),里面的多个数据同时赋值多个变量,解释器会进行拆包操作
注意: 拆包要注意被赋值的变量个数和元组中的值个数相同

"""拆包"""
tuple = ("静静", 18, "女")
name, age, sex = tuple
print(name, age, sex) # 静静 18 女

"""组包"""
name, age, sex = "静静", 18, "女"
tuple = (name, age, sex)
print(tuple)  # ('静静', 18, '女')

3. 模块：一个py文件成为一个模块

九、if条件判断：分支结构

1.单分支

if  条件:
	语句块

2.双分支

if  条件1：
	语句块1
else：
	语句块2

3.多分支

if  条件1：
	语句块1
elif  条件2：
	语句块2
elif 条件3：
	语句块3
......
[else: # 可选
	语句块4

4.分支嵌套

if 条件1：
	if条件2：
		语句块1
	else：
		语句块2
else：
语句块3

十、循环

1. while 循环

while  条件：
           语句块
死循环
    终止   break
    跳过本次继续下一个 continue

2. for 循环

万物皆可 for

2.1 for 循环遍历、迭代

2.1.1 通过值遍历

"""通过值遍历"""
for 变量 in 可迭代数据（str / list / tuple / range()）:
    循环体

2.1.2 通过下标遍历列表、字典、集合

"""通过下标遍历列表、字典、集合"""
for i in rang（len(list):
    print(list[i])

2.2 for嵌套

for i in range(4):
    for j in range(5):
        print('*', end='')
    print()
# *****
# *****
# *****
# *****

2.2.1 练习题

2.2.1.1 九九乘法表

for row in range(1, 10):  # 1,2,3,4,5,6,7,8,9   行
    for column in range(row):  # 0,1,2,3,4,5,6,7,8   列
        print('{}*{}={}\t'.format(column + 1, row, ((column + 1) * row)), end='')
    print()

for i in range(1, 10):
    j = 1
    while j <= i:
        print('%d*%d=%d\t' % (j, i, i * j), end='')
        j += 1  # 表达式表达式表达式
    print()

九九乘法表详细讲解

2.2.1.2 冒泡排序

list1 = [9, 2, 1, 4, 6, 3]
for i in range(len(list1) - 1):  
    for j in range(len(list1) - 1 - i):  
        if list1[j] > list1[j + 1]:  
            list1[j], list1[j + 1] = list1[j + 1], list1[j]
print(list1)  # [1, 2, 3, 4, 6, 9]