Python基础学习备忘录上

Python语法

1.1 输出

1.1.1 输出换行的更改

# 更改换行字符，默认换行符
print("Hello World")
print("Hello", end="*")
print("World")

输出如下：
python输出默认有换行符，可以通过end更改

1.1.2 输出整型

# 整形输出，6**2为次方输出 3//2为整除 3/2为除
print(6**2)
print(3//2)
print(3/2)

输出如下

整型输出不需要加单引号或者双引号

1.1.3 输出字符串

# 字符串输出“” ‘’都是同样的效果
print("String Str")
print('String Str')

# 字符串输出特例：“”“ ”“”  ''' ''' 三个引号可输出换行效果
print("String "
      "Str")
print("""String
         Str""")

输出如下：

对于字符串输出，单引号与双引号都可以实现，其中特别的可以通过三引号实现换行符\n的录入。

1.1.4 字符串拼接与多行输出

# 字符串乘与加操作
# 字符串拼接
print("Hello"+"World")

# 同一字符串同行多输出
print(3*"HelloWorld")

输出如下：
可通过+号实现字符串的相加输出操作，可通过数值*字符串的形式实现同一字符串的多行输出。

1.1.5 输入输出类型转换

# 类型转换
# 字符串到整形
print("6"+"9")
print(int("6")+int("9"))

# 整形到字符串
print(str(123))
print(str(123)+str(123))

输出如下：
类型转换的实现，可以通过 想要转换成类型名（将要转换的变量）的形式实现转换。

# bool类型转换
# bool与整数
print(bool(0))
print(bool(1))
print(bool(2))
print(bool(-10))

# bool与字符串
print(bool("Str"))
print(bool(" "))
print(bool(""))

输出如下：

对于其他类型向布尔类型的转换，当且仅当要转换的为空字符串（”“）和 0 时转换后的布尔变量输出是 false 其他都是 true。

1.2 条件语句与循环语句

1.2.1 条件语句基本格式

#条件语句基本格式
if 条件1:
	if内语句1
	if内语句2
	...
else:
	else内语句1
	else内语句2
	...
其他语句语句1

if基本格式如上，通过四个空格（一个TAB）实现内外区分。代码测试如下：

statement = True
if statement:
    print("statement的值为True")
else:
    print("statement的值为False")
    print("条件判断语句执行结束")

if statement:
    print("statement的值为True")
else:
    print("statement的值为False")
print("条件判断语句执行结束")

测试其内外区分如上所示，第一个 print（”条件判断语句执行结束“）相较于第二个区别即是在于是否有四个空格（ 一个 TAB ）则分别属于else内部和外部指令。

1.2.2 多条件判断格式

#多条件判断格式
if 判断语句1:
	执行语句1
	...
elif 判断语句2:
	执行语句2
	...
...
else:
	执行语句3
	...
其他语句1 

其中具体判断代码如下：

# 多条件判断 if- else 基本格式
tmp_input = input("每月的工资")
money = int(tmp_input)
if money <= 2000:
    print("ByeBye~")
elif money <= 6000:
    print("Hello")
elif money <= 10000:
    print("Yes,Sir")
else:
    print("Dad")

输出如下：

控制台中输入12000返回相应函数，通过 if-elif 字段实现 if-else 格式

1.2.3 if 嵌套格式

#if 嵌套格式如下
if 判断条件1:
	if 内语句1
	if 内语句2
	...
	if 判断条件2:
		if 内语句1
		if 内语句2
		...
	else:
		else 语句1
		else 语句2
		...
else:
	else 语句1
	else 语句2
	...
其他语句1

# if嵌套的格式
tmp_input = input("你是猪吗？")
Str = tmp_input
if Str == 'Y':
    tmp_input = input("真的吗？")
    Str = tmp_input
    if Str == 'Y':
        print("🐖")
    else:
        print("假的")
else:
    print("不是")

输出如下：

嵌套的实现即是继续往后缩进即可。

1.2.4 while 循环基本格式

#while 循环基本格式
while 循环条件1:
	循环语句1
	循环语句2
	...
语句1

其中具体的测试代码如下：

#while循环基本格式
statement = 0
target = 3
while statement < target:
    statement = statement + 1
    print(statement, target)
print('循环结束')

输出如下：

在满足执行条件，即是执行条件的值为true时，将一直顺序执行循环语句

1.2.5 while - break 基本格式

# while-break基本格式
while 循环条件1:
	循环语句1
	循环语句2
	break
	循环语句3
	...
其他语句1

具体测试代码如下所示：

# while-break基本格式
statement = True
while statement:
    print('科西嘉的怪物在儒安港登陆')
    print('吃人的魔鬼向格腊斯前进')
    print('篡位者进入格勒诺布尔')
    print('波拿巴占领里昂')
    print('拿破仑接近枫丹白露')
    break
    print('......')
    print('******')
print('皇帝陛下将于今日抵达他忠实的巴黎')

输出如下：
循环语句执行到break时直接跳出循环，break之下的循环内语句不执行。

1.2.6 while - continue基本格式

# while-continue基本格式
while 循环条件1:
	循环语句1
	循环语句2
	continue
	循环语句3
	...
其他语句1

具体测试代码如下所示：

# while-continue基本格式
time = 0
while time < 3:
    print('循环次数:', time)
    print('这行能打印出来')
    time = time + 1
    continue
    print('这行是打印不出来的')
    print('这行也是')
print('循环结束')

输出如下所示：

在循环执行到continue时将结束本次循环，继续下一次循环，直到不满住循环条件。

1.2.7 while - else 基本格式

#while-else基本格式(while 不成立时候执行else内部代码)
while 循环条件1:
	循环语句1
	循环语句2
	...
else:
	else语句1
	else语句2
	...
其他语句1

具体测试代码如下所示：

# while-else基本格式(while 不成立时候执行else内部代码)
time = 1
while True:
    print("这是第"+str(time)+"次循环")
    if time == 3:
        break
    time = time + 1
else:
    print('break方式不会执行else内容')
print('循环结束')

time = 1
while time <= 3:
    print("这是第"+str(time)+"次循环")
    time = time + 1
else:
    print('没有break方法，在while执行完后会执行else内容')
print('循环结束')

输出如下：

else 之中的内容会在执行完 while 循环后执行，但是特别的：如果通过 break 的方式跳出 while 循环将不会执行 else 中语句块。

1.2.9 通过 for 与 range函数实现循环基本格式

基本格式如下：

for 循环类型 in 循环的结构
	循环语句1
	循环语句2
	...
语句1

for i in range(begin,end)
	循环语句1
	循环语句2
	...
语句1

具体测试代码如下：

# for循环
string = "你好世界"
# 全部输出
for char in string:
    print(char)
# 输出字符1到2 
for i in range(0, 2):
    print(string[i])
# 全部输出
for i in range(len(string)):
    print(string[i])

输出结果如下：

1.3 格式化字符串与运算符与进制转换

1.3.1 通过 % 实现字符串格式化

通过%实现字符串格式化操作的基本格式

%实现字符串格式化基本格式
txt = "内容1%s内容2" %"用于填充%s处的String"

具体测试代码如下所示：

#%完成，字符串格式化
name = "王腾"
txt = "我儿%s有大帝之姿" %name
print(txt)

输出如下：

通过%实现多参数字符串格式化方法基本格式

通过%实现多参数字符串格式化方法基本格式
str1 = "string1"
str2 = "string2"
txt = "内容1%s内容2%s" %(str1,str2)

具体测试代码如下所示：

ss_age = '三'
s_age = '三十'
n_age = '三百'
b_age = '三千'
txt = "女大%s抱金砖。女大%s十送江山。女大%s送仙丹。女大%s位列仙班。" %(ss_age,s_age,n_age,b_age)
print(txt)

输出如下：

通过%实现多参数字符串格式化方法的第二种格式

通过%实现多参数字符串格式化方法2
str1 = "string1"
str2 = "string2"
txt = "内容1%(n1)s内容2%(n2)s" %{"n1":str1,"n2":str2}

具体测试代码如下所示：

s_age = '三万'
n_age = '三十万'
b_age = '三百万'
txt="女大%(n1)s王母喂饭。女大%(n2)s，佛祖门口站。女大%(n3)s，三界你说了算。" %{"n1": s_age,"n2": n_age,"n3": b_age}
print(txt)

输出结果如下：

需要注意的是，此处同基本格式1不同 % 后接的为中括号 { } 而不是小括号 （ ）

特别的如果文本中原本带有 % 符号，在用 % 实现字符串格式化时，需要在文本内容的 % 后面再加上一个 % ，示意此为文本内容，而不是占位符。

具体测试代码如下所示：

ps = "在使用%方法完成字符串格式化，如果字符串本身有%，需要在%后面再加一个%"
ps = "在使用%s完成字符串格式化时，如果字符串本身有%%，需要在%%后面再加一个%%" %('%方法')
print(ps)

输出如下所示：

1.3.2 通过format 实现字符串格式化

format 方法实现字符串格式化基本格式如下：

#默认
txt = "内容1{0}内容2{1}".format("str1","str2")
txt = "内容1{}内容2{}".format("str1","str2")
#自定义
txt = "内容1{s1}内容2{s2}".format(s1="str1",s2="str2")

具体测试代码如下所示：

#format方法实现字符串格式化
# 默认
txt = "女大{0}，六界围着你转。女大{1}，开天辟地。女大{2}，盘古做小弟.".format("三千万", "三亿", "三十亿")
print(txt)
txt = "女大{}，六界围着你转。女大{}，开天辟地。女大{}，盘古做小弟.".format("三千万", "三亿", "三十亿")
print(txt)
# 自定义
txt = "女大{a1}，手搓银河系。女大{a2}，徒手干爆九天十地。".format(a1="三百亿", a2="三千亿")
print(txt)

输出结果如下：

1.3.3 通过 f 实现字符串格式化

f 实现字符串格式化基本格式如下：

# f方法实现字符串格式化 py3.6.0以上版本新增
str = "string1"
txt = f"内容1{str}内容2"

具体测试代码如下所示：

# f方法实现字符串格式化 py3.6.0以上版本新增
name = "李淳罡"
txt = f"天不生我{name}，剑道万古如长夜"
print(txt)

输出结果如下：

1.3.4 成员运算符 in 与 not in

基本格式：

str string
str txt
bool bl
bl = string in txt #string not in txt

检测 txt 字符串中，是否含有 string 字符，如果有返回布尔变量 true,没有返回 false

具体测试代码如下

# 成员运算符 in 与 not-in
txt = "菊花很美丽，不是一般的美丽，象征着高洁和雅净"
danger = "菊花"
if danger in txt:
    print("txt中有{n1}".format(n1=danger))
else:
    print("txt中没有{n1}")

if danger not in txt:
    print("txt中没有{n1}")
else:
    print("txt中有{n1}".format(n1=danger))

输出如下：

1.3.5 逻辑运算符 and 与 or 与 not

基本格式：

b1 = True
b2 = True
b3 = False
b3 = b1 and b2
b3 = b1 or b2
b3 = not b1

具体测试如下：

# 逻辑运算
true = True
false = False
if true and false:
    print("true && false = True")
else:
    print("true && false = False")
if true or false:
    print("true || false = True")
else:
    print("true || false = False")
if not true:
    print("not true is true")
else:
    print("not true is false")

输出如下：

通过 and 和 or 字符分别代替 && 和 || 实现 ”与“ 、”或“。not 字符实现“非”操作。

1.3.6 十进制到二、八、十六进制的转换

十进制转换其他进制基本格式:

int targe
#十进制到二进制
num = bin(target)
#十进制到八进制
num = oct(16)
#十进制到十六进制
num = hex(16)

具体测试代码如下：

# 十进制转二进制、八进制、十六进制
number = bin(16)
print(number)
number = oct(16)
print(number)
number = hex(16)
print(number)

输出如下所示：

前两位为进制，二进制为0b,，八进制为0o，十六进制为0x

1.3.7 二、八、十六进制到十进制的转换

其他进制到十进制的转换基本格式：

num = int("二、八、十六进制数",base=2 or 8 or 16)

具体测试代码如下：

# 二进制、八进制、十六进制转十进制
number = int("0b10000", base=2)
print(number)
number = int("0o20", base=8)
print(number)
number = int("0x10", base=16)
print(number)

其输出如下：

2.1 字符串

2.1.1 判断字符串开头结尾是否包含某些字符

基本格式如下：

str string
str txt
bool b1
b1 = txt.startswith(string)
b1 = txt.endswith(string)

具体测试代码如下：

# 判断字符串开头结尾
txt = "你好，再见"
if txt.startswith("你好"):
    print("txt开头中有字符你好")
else:
    print("txt开头中没有字符你好")
if txt.endswith("再见"):
    print("txt结尾中有字符再见")
else:
    print("txt结尾中没有字符再见")

运行结果如下：

2.1.2 判断字符串是否为全数字

三种方法基本格式：

bool b1
str string
# string 内是否全为数字字符。
b1 = string.isdigit()
# string 内是否全为十进制字符
b1 = string.isdecimal()
# string内是否全为数值字符
b1 = string.isnumeric()

具体测试代码如下：

# 字符串中数值检测
print("测试三者为分别为:isdigit(),isdecimal(),isnumeric()")
num = "零"
print("汉字罗马字符 零 三者输出为", end=':')
print(num.isdigit(), end=',')
print(num.isdecimal(), end=',')
print(num.isnumeric())
num = "2.3"
print("三者小数 2.3 输出为", end=':')
print(num.isdigit(), end=',')
print(num.isdecimal(), end=',')
print(num.isnumeric())
num = "123"
print("三者十进制 123 输出为", end=':')
print(num.isdigit(), end=',')
print(num.isdecimal(), end=',')
print(num.isnumeric())
num = "①"
print("三者数值字符 ① 输出为", end=':')
print(num.isdigit(), end=',')
print(num.isdecimal(), end=',')
print(num.isnumeric())

具体输出如下：

	单字节数字	双字节全角数字	Unicode数字	汉字罗马字符	小数
isdigit()	✔	✔	✔	×	×
isdecimal()	×	✔	✔	×	×
isnumeric()	✔	✔	✔	✔	×

2.1.3 字符串两边特定字符去除

基本格式如下：

str string
str target
#去除字符两边的换行符、制表符、空格
string = string.strip()
#指定去除字符串两边字符
string = string.strip(target)
#指定去除字符串左边字符
string = string.lstrip()
#指定去除字符串右边字符
string = string.rstrip()

具体测试代码如下：

# 字符串两边字符删减
txt = "洞帘水挂水帘洞，山果花开花果山\n"
print(txt+"有个换行符")
txt = txt.strip()
print(txt+" 没有换行符")
txt = "洞帘水挂水帘洞"
atxt = txt.strip("洞")
ltxt = txt.lstrip("洞")
rtxt = txt.rstrip("洞")
print("两边的洞都没了:"+atxt)
print("左边的洞都没了:"+ltxt)
print("右边的洞都没了:"+rtxt)

输出结果：

2.1.4 字符串大小写变化

基本格式：

str string
#全部转换为小写
string = string.lower()
#全部转换为大写
string = string.upper()

具体测试代码:

# 字符串大小写变化
txt = "i love you"
print(txt)
TXT = txt.upper()
print(TXT)
txt = TXT.lower()
print(txt)

输出如下：

2.1.5 字符串内容替换

基本格式：

str txt
str string
str target
txt= string.replace(string,target)

具体测试代码如下；

# 字符串字符替换
txt = "你是狗吗？死狗"
string = "狗"
target = "🐕"
print(txt)
print(txt.replace(string, target))

具体输出如下：

2.1.6 字符串切割与拼接

字符串切割基本格式：

str data
str flag
list data_list
int time
#从左往右切割，切割标志为flag 默认全部切割
data_list = data.split(flag)
#从左往右切割，切割标志为flag 可设置time具体切割多少次
data_list = data.split(flag,time)
#从右往左切割，切割标志为flag 默认全部切割
data_list = data.rsplit(flag)
#从右往左切割，切割标志为flag 可设置time具体切割多少次
data_list = data.rsplit(flag)

字符串切割具体测试如下：

# 字符串切割
data = "地球.中国.四川省.绵阳市"
area_list = data.split('.')
print(area_list)
area_list = data.split('.', 1)
print(area_list)
area_list = data.rsplit('.')
print(area_list)
area_list = data.rsplit('.', 1)
print(area_list)

输出结果：

字符串拼接基本格式：

list data_list
str data
str flag
data = flag.join(data_list)

字符串拼接具体测试如下：

# 字符串拼接
data_list = ['地球', '中国', '四川省', '绵阳市']
flag = "."
data = flag.join(data_list)
print(data)

输出如下：

2.1.7 字符串字节相互转化

基本格式：

str string 
str cstring
str str_type
#字符串转化为字节
cstring= string.encode(str_type)
#字节转换为字符串
string= cstring.decode(str_type)

具体测试如下:

# 字符串字节相互转化
string = "Hello World 你好 世界"
str_type = "utf-8"
c_string = string.encode(str_type)
print(c_string)
print(c_string.decode(str_type))

具体输出如下：

2.1.8 字符串内容填充设置

基本格式：

str string
str data
str sign
int width
#字符串居中设置
data = string.center(width,sign)
#字符串居左设置
data = string.ljust(width,sign)
#字符串居右设置
data = string.rjust(width,sign)
#字符串前面用0填充
data = string.zfill(width)

具体测试代码：

# 字符串填充
string = "(°°)～"
sign = "?"
width = 10
data = string.ljust(width, sign)
print(data)
data = string.center(width, sign)
print(data)
data = string.rjust(width, sign)
print(data)
data = string.zfill(width)
print(data)

输出结果：

2.1.9 字符串索引、切片与步长

基本格式：

int num
int begin 
int end
int step
str string
#字符串索引,仅输出不可修改
string[num]
#字符串切片,仅输出不可修改
string[begin:end]
#字符串步长（跳跃取值）,仅输出不可修改
string[begin:end:step]

具体测试代码如下：

string = "🐀🐂🐅🐇🐉🐍🐎🐏🐒🐓🐕🐖"
num = 0
begin = 1
end = 10
step = 2
print(string[num])
# 字符串最后一个值
print(string[-1])
print(string[begin:end])
print(string[begin:end:step])
# 字符串倒序输出，需要注意的是此时代表从字符串最后一个到第二个倒序输出
print(string[-1:0:-1])
# 字符串倒序输出，此时为整体的倒序输出
print(string[-1::-1])

输出结果如下：

2.2 列表

2.2.1 列表定义与添加打印

列表定义和添加打印的基本格式：

# 列表与数组不同，列表可以放不同数据类型的元素
data_list=[str,int]
# 列表元素的单个添加
data_list.append(str)
# 直接添加另外的列表元素
data_list.extend(new_list)
# for循环实现列表元素的批量添加
for item in new_list:
	data_list.append(item)

具体测试代码：

# 列表的定义与批量添加
data_list = ["闭月羞花", "国色天香"]
new_list = ["明目皓齿", "冰肌玉骨"]
new_list2 = ["倾国倾城", "貌美如花"]
# 原始data_list数据
print(data_list)
# append单个添加
data_list.append("小家碧玉")
print(data_list)
# expend整个列表元素添加
data_list.extend(new_list)
print(data_list)
# for循环添加
for item in new_list2:
    data_list.append(item)
print(data_list)

输出结果如下：

2.2.2 列表插入和删除

列表插入和删除的基本格式：

data_list = [str,int]
int index
# 列表插入insert(索引位置,插入的内容)
# 索引值过大或者过小将会把数据放在最后方、最前方
data_list.insert(index,str)

# 根据数值查询实现删除remove(待删除元素)
# 一次remove仅仅会删除一个元素
# 列表中没有对应元素会报错
data_list.remove(str)

# 根据索引删除列表中元素
# 删除列表中最后一个元素
delete = data_list.pop()
# 删除列表中对应索引的元素
delete = data_list.pop(index)

# 清空整个列表
data_list.clear()

具体测试代码：

# 列表插入和删除
data_list = ["老大建了草屋子", "老二建了木屋子", "老三建了砖屋子"]
print(data_list)
# 在老大后面插入🐖
data_list.insert(1, "🐖")
print(data_list)
# 在最前方插入大🐖
data_list.insert(-100, "大🐖")
print(data_list)
# 在最后方插入小🐖
data_list.insert(100, "小🐖")
print(data_list)
# 移除掉🐖
data_list.remove("🐖")
print(data_list)
# 清除掉小🐖
data_list.pop()
print(data_list)
# 清除掉大🐖
data_list.pop(0)
print(data_list)
# 清除整个列表
data_list.clear()
print(data_list)

输出结果如下：

2.2.3 列表索引查询和排序

列表定义和添加打印的基本格式：

# 列表索引查询，根据值查询索引，如果查询元素找不到则会报错
int index
data_list = [int,str]
# index(待查询元素)  实现
index = data_list.index(str)
# 列表排序 从小到大
data_list.sort()
# 列表排序，从大到小
data_list.sort(reverse=True)
# 列表反转
data_list.reverse()

具体测试代码：

# 列表索引和排序
data_list = [9,8,7,6,5,4,3,2,1]
print(data_list)
# 通过值查询索引
index = data_list.index(9)
print(index)
# 从小到大
data_list.sort()
print(data_list)
# 从大到小
data_list.sort(reverse=True)
print(data_list)
# 字符串比较,str与int不能比较
data_list = ["G", "F", "E", "D", "C", "B", "A"]
print(data_list)
# 列表反转
data_list.reverse()
print(data_list)

输出结果如下：

2.2.4 列表加乘，in与长度获取

列表加乘，in与长度获取的基本格式：

list data_list
list data_list2
# 列表相加
list = data_list + data_list2
# 列表相乘
list = data_list * int
# 列表 in 与 not in
bool = str in data_list
bool = str not in data_list
# 列表长度获取
len(data_list)

具体测试代码：

data_list = ["C", "C#", "C++"]
data_list2 = ["Java", "Python"]
print(data_list + data_list2)
print(len(data_list+data_list2))
print(data_list * 3)
# 遍历循环
if "C" in data_list:
    print("C是世界上最好的语言")

输出结果如下：

2.2.5 列表索引、切片、步长

列表索引、步长、切片的基本格式：

list data_list
# 列表索引 int 不能超过索引范围，不然会报错
data_list[int]
# 列表索引删除
del data_list[int]

# 列表切片 取左不取右，左边0和C语言依赖保持一致，后边是直观显示
# 切片索引超过范围不会报错
data_list[int:int]
# 切片删除
del data_list[int:int]
# 切片修改,覆盖步长区域的修改方式
data_list[int:int] = [str,str]

# 列表步长[起点索引:终点索引:步长]
data_list[int:int:int]

具体测试代码：

# 列表索引、切片、步长
data_list = ["子鼠", "丑牛", "寅虎", "卯兔", "辰龙", "巳蛇", "午马", "未羊", "申猴", "酉鸡", "戌狗", "亥猪"]
print(data_list)
# 打印列表索引为0的元素
print(data_list[0])
# 打印列表前六个元素
print(data_list[0:6])
# 前六个元素步长为2打印
print(data_list[0:6:2])
# 删除第一个元素
del data_list[0]
print(data_list)
# 切片方式删除现在第一个元素
del data_list[0:1]
print(data_list)
# 将列表中的第一个元素用["子鼠", "丑牛", "寅虎"]覆盖修改
data_list[0:1] = ["子鼠", "丑牛", "寅虎"]
print(data_list)

输出结果如下：

2.2.6 列表嵌套

列表嵌套的基本格式：

data_list = [str,int,bool,list]
# 调用嵌套列表[data_list索引][元素自身内部索引]
data_list[int][int]

具体测试代码：

# 列表嵌套
table_list = ["正文1", "正文2", "正文3"]
txt_list = ["标题1", "标题2", "标题3", "标题4", table_list]
# 整个列表输出
print(txt_list)
# 列表中列表输出
print(txt_list[-1])
# 列表中列表单个输出
print(txt_list[-1][0])

输出结果如下：

2.3 元组、集合与字典

2.3.1 元组定义与简单使用

元组定义与简单使用的基本格式：

# 元组有序，内部元素不可修改，可以添加
tuple = (str,int,list,bool)
# 元组相加
tuple + tuple
# 元组相乘
tuple * int
# 获取长度
len(tuple) 
# 索引
tuple[int]
# 切片
tuple[int:int]
# 步长
tuple[int:int:int]

具体测试代码：

# 元组定义
data_tuple = ("早餐", "午餐", "晚餐", "不能有宵夜")
# 打印元组
print(data_tuple)
# 打印两元组相加
print(data_tuple + data_tuple)
# 打印三个元组
print(data_tuple * 3)
# 打印元组长度
print(len(data_tuple))
# 打印元组第一个元素
print(data_tuple[0])
# 打印元组第一个到第二个元素
print(data_tuple[0:2])
# 打印元组第一个到第四个元素，步长为2
print(data_tuple[0:4:2])
# 特殊定义 (0)为整型，(0,)为元组
num = (0)
num_tuple = (0,)
# 打印输出为整型
print(num)
# 打印输出为元组
print(num_tuple)

输出结果如下：

2.3.2 集合定义与简单使用

集合定义与简单使用的基本格式：

# 集合是无序的，可变的，值不可重复的、采用哈希实现存储
data_set = {str,int,bool}
# 空集合定义
data_set = set()
# 集合元素添加
data_set.add(str)
# 集合元素删除
data_set.discard(str)
# 集合交集[两者等价]
set = data_set & data_set2
set = data_set.intersection(data_set2)
# 集合并集[两者等价]
set = data_set | data_set2
set = data_set.union(data_set)
# 集合差集[两者等价]
set = data_set - data_set2
set = data_set.difference(data_set2)

具体测试代码：

data_set1 = {0, 1, 2, 3, 4, 5}
data_set2 = {3, 4, 5, 6, 7, 8}
# 打印data_set1集合
print(data_set1)
# 在集合中添加元素并打印
data_set1.add(6)
print(data_set1)
# 在集合中删除元素并打印
data_set1.discard(6)
print(data_set1)
# 打印两个集合的交集
print(data_set1 & data_set2)
# 打印两个集合的并集
print(data_set1 | data_set2)
# 打印两个集合的差集
print(data_set1 - data_set2)

输出结果如下：

2.3.3 字典定义与简单使用

字典定义与简单实用的基本格式：

# 字典可变，存在键值对，键不重复，且必须可哈希，值为任意值
data_dict = {key1:value,key2:value}
# 输出键所对应的值
data_dict.get(key)
# 输出所有键
data_dict.keys()
# 输出所有值
data_dict.values()
# 输出所有的键值
data_dict.items()

具体测试代码：

data_dict = {
    "name": "林某某",
    "age": 18,
    "class": "信安1702"
}
# 打印字典内容
print(data_dict)
# 打印name键内的值
print(data_dict.get("name"))
# 打印所有的键
print(data_dict.keys())
# 打印所有的值
print(data_dict.values())
# 打印所有的键值
print(data_dict.items())
# 循环打印
for item in data_dict.items():
    print(item[0], item[1])

输出结果如下：

2.3.4 字典键值更改

字典键值更改的基本格式：

# 初始化设置字典内键值，如果键存在，则不做更新
data_dict.setdefault(key,value)
# 更新字典键值对内容
data_dict.update({key1:value1,key2:value2})
# 移除指定键值对
value = data_dict.pop(key)
# 移除最后的值
tuple = data_dict.popitem()
# 根据键获取对应值,键不存在则报错
data_dict[key]
# 字典值修改和删除
data_dict[key] = value
del data_dict[key]

具体测试代码：

# 字典键值对操作
data_dict = {
     "name": "林某某",
     "class": "信安1702"
}
# 字典键值对设置
data_dict.setdefault("sex", "女")
print(data_dict)
# 在已经存在对应键值时，此操作无效
data_dict.setdefault("sex", "男")
print(data_dict)
# 更新字典
data_dict.update({"age": 18, "name": "某某林"})
print(data_dict)
# 根据键值移除键值对
value = data_dict.pop("name")
# 获取被移除的键值
print(value)
# 移除后的字典
print(data_dict)
# 移除最后的键值
data = data_dict.popitem()
print(data)
print(data_dict)
# 根据索引获得键值
print(data_dict["class"])
# 更改值
data_dict["class"] = "信安1602"
print(data_dict)
# 删除值
del data_dict["class"]
print(data_dict)

输出结果如下：