Python学习

print('hello world')

# 输出数字
print(520)
print(98.5)

# 输出字符串
# 单引号
print('hello world')
# 双引号
print("hello world")
# 三引号
print("""hello world""")

# 含有运算符的表达式
print(3 + 1)

# 将数据输出到文件中
_file = open('./text.txt', 'a+')
# a+：如果文件不存在就创建，存在就在文件内容的后面继续追加
print('hello world', file=_file)
_file.close()

# 不进行换行输出（输出内容在一行当中）
print('hello', 'world', 'Python')

# 转义字符
# \ + 转义功能的首字母 n：newline的首字符表示换行
print('hello\nworld')
# 制表符
print('hello\tworld')
print('helloooo\tworld')
# 回车：world将hello进行了覆盖
print('hello\rworld')
# \b是退一个格，将o退没了
print('hello\bworld')

# 反斜杠转义
print('http:\\\\www.baidu.com')
print('你好：\'hello\'')

# 原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r，或R
print(r'hello\nworld')
# 注意事项：原字符最后一个字符串不能是反斜杠
# print(r'hello\nworld\')

# 十进制unicode
print(ord('乘'))

# 十进制转二进制
print(bin(ord('乘')))

# 二进制
print(chr(0b100111001011000))

import keyword
print(keyword.kwlist)

# name变量名
# =复制运算符
# myname值
name = 'my name'

name = 'my name'
print('标识', id(name))
print('类型', type(name))
print('值', name)

name = 'my name'
print('标识', id(name))
print('类型', type(name))
print('值', name)

print('---------')
name = 'new name'
print('标识', id(name))
print('类型', type(name))
print('值', name)

# 第一个数据5792没有被使用变成了内存垃圾
# 标识 4343655792
# 类型 <class 'str'>
# 值 my name
# ---------
# 标识 4343632112
# 类型 <class 'str'>
# 值 new name

# 整数类型
# 可以表示，正数，负数，0
n1=90
n2=-76
n3=0
print(n1, type(n1))
print(n2, type(n2))
print(n3, type(n3))

# 整数可以表示为二进制，十进制，八进制，十六进制
print('十进制', 118)
print('二进制', 0b1110110)
print('八进制', 0o166)
print('十六进制', 0x76)

from decimal import Decimal

a=3.14159
print(a, type(a))

n1=1.1
n2=2.2
print(n1 + n2)

print(Decimal(n1.__str__()) + Decimal(n2.__str__()))

f1 = True
f2 = False

print(f1, type(f1))
print(f2, type(f2))

# 布尔值可以转成整数计算
print(f1 + 1)  # 1 + 1
print(f2 + 1)  # 0 + 1

str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = """人生苦短，我用Python"""

str4='''人生苦短，我用Python'''

print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))
print(str4, type(str4))

name = '张三'
age = 20

print(type(name), type(age))  # 说明name与age的数据类型不相同
# print('我叫' + name + '今年,' + age + '岁')  # 将str类型与int类型进行连接时，报错，解决方案，类型转换
print('我叫' + name + '今年,' + str(age) + '岁')

print('-------------str()将其他类型转成str类型---------------')
a = 10
b = 198.8
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c))
print(type(str(a)), type(str(b)), type(str(c)))

print('-------------int()将其他类型转成int类型---------------')
s1 = '128'
s2 = '76.77'
s3 = 'hello'
f1 = 98.7
ff = True

print(type(s1), type(s2), type(s3), type(f1), type(ff))
print(int(s1), type(s1))  # 将str类型转成int类型，字符串为数字串
# print(int(s2), type(s2))  # 将str类型转成int类型，报错，因为字符串为小数字符串
# print(int(s3), type(s3))  # 将str类型转成int类型时，字符串必须为数字字符串（整数），非数字串不允许转换
print(int(f1), type(f1))  # float转成int类型，截取整数部分，舍掉小数部分
print(int(ff), type(ff))

print('-------------float()将其他类型转成float类型---------------')

s1 = '128.98'
s2 = '76'
s3 = 'hello'
ff = True
i = 98

print(type(s1), type(s2), type(s3), type(ff), type(i))
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
# print(float(s3), type(float(s3)))  # 字符串中的数据如果是非数字字符串，则不允许转换
print(float(ff), type(float(ff)))
print(float(i), type(float(i)))

# coding:gbk

# 输入功能（单行注释）
print('hello')

'''
多行注释
'''

# present：变量
# =：赋值运算符，将输入函数的结果赋值给变量
# input()是一个输入函数，需要输入回答
present = input('输入内容')

present = input('输入内容')
print(present, type(present))

a = int(input('输入一个加数'))
b = int(input('输入另一个加数'))

print(type(a), type(b))
print(a + b)

print(1 + 1)  # 加法运算
print(1 - 1)  # 减法运算
print(2 * 4)  # 乘法运算
print(1 / 2)  # 除法运算
print(11 / 2)  # 除法运算
print(11 // 2)  # 5 整除运算
print(11 % 2)  # 取余运算
print(2 ** 2)  # 表示2的2次方
print(2 ** 3)  # 表示2的三次方

print('--------------')
print(9 // 4) # 2
print(-9 // -4) # 2

print(9 // -4) # -3
print(-9 // 4) # -3 一正一负的整数公式，向下取整

print(9 % -4) # -3 公式 余数=被除数-除数*商 9-(-4)*(-3) 9-12 = -3
print(-9 % 4) # 3  -9-4*(-3) -9+12 = 3

a = 3 + 4
print(a)

a = b = c = 20
print(a, id(a))
print(b, id(b))
print(c, id(c))
print('-------支持参数赋值-------')
a = 20
a += 30  # 相当于a=a+30
print(a)
a -= 10  # 相当于a=a-10
print(a)
a *= 2
print(a)
a /= 3  # 相当于a=a*2
print(a)
print(type(a))  # float
a //= 2
print(a)
a %= 3
print(a)

print('-------------解包赋值--------------')
a, b, c = 20, 30, 40
print(a, id(a))
print(b, id(b))
print(c, id(c))

# a,b=20,30,40 报错，因为左右变量的个数和值的个数不对应
print('-------------交换两个变量的值--------------')
a, b = 10, 20
print('交换之前：', a, b)
# 交换
a, b = b, a
print('交换之后：', a, b)

a, b = 10, 20
print('a>b', a > b)  # False
print('a<b', a < b)  # True
print('a<=b', a <= b)  # True
print('a>=b', a >= b)  # False
print('a==b', a == b)  # False
print('a!=b', a != b)  # True

'''
    一个=称为赋值运算符，==称为比较运算符
    一个变量由三部分组成，标识，类型，值
    == 比较的是值，比较对象的标识使用is
'''
a = 10
b = 10
print(a == b)  # True 说明a与b的value相等
print(a is b)  # True 说明a与b的id标识相等

list1 = [11, 22, 33, 44]
list2 = [11, 22, 33, 44]
print(list1 == list2)  # value True
print(list1 is list2)  # id False
print(id(list1))
print(id(list2))

print(a is not b)  # False
print(list1 is not list2)  # True

a, b = 1, 2
print('-------------and并且-----------------')
print(a == 1 and b == 2)  # True
print(a == 1 and b < 2)  # False
print(a != 1 and b == 2)  # False
print(a != 1 and b != 2)  # False

print('-------------or或者-----------------')
print(a == 1 or b == 2)  # True
print(a == 1 or b < 2)  # True
print(a != 1 or b == 2)  # True
print(a != 1 or b != 2)  # False

print('-------------not对bool类型操作数取反-----------------')
f = True
f2 = False
print(not f)
print(not f2)

print('-------------in与not in-----------------')
s='helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)

# 4的二进制：0000 0100
# 8的二进制：0000 1000
# 对应位数都为1结果才是1：0000 0000
print(bin(4))
print(bin(8))
# 按位与&，同为1时结果才为1
print(4 & 8)

# 对应位数都是0，结果位数才是0：0000 1100
print(0b00001100)
# 按位或|，同为0时结果为0
print(4 | 8)


# 左移位：左高位截断，右低位补0
# 0000 1000，一位，相当于乘以2
print(0b00001000)
# 向左移动1位（移动1个位置）
print(4 << 1)
# 0001 0000，二位，相当于乘以4
print(0b00010000)
# 向左移动2位（移动2个位置）
print(4 << 2)

# 右移位：左高位补0，右低位截断
# 0000 0010，一位，相当于除以2
print(0b00000010)
# 向右移动1位（移动1个位置）
print(4 >> 1)
# 0000 0001，二位，相当于除以4
print(0b00000001)
# 向右移动2位（移动2个位置）
print(4 >> 2)

# 对象的布尔值
print(bool(False))  # False
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(None))  # None
print(bool(''))  # 空字符
print(bool(""))  # 空字符
print(bool([]))  # 空列表
print(bool(list()))  # 空列表
print(bool(()))  # 空元组
print(bool(tuple()))  # 空元组
print(bool({}))  # 空字典
print(bool(dict()))  # 空字典
print(bool(set()))  # 空集合

if 条件表达式:
		条件执行体

money = 1000
s = int(input('输入取款金额'))
# 判断余额是否充足
if money >= s:
    money -= s
    print('取款成功，余额为:', money)

if 条件表达式:
  	条件执行体1
else:
  	条件执行体2

# 双分支结构if...else，二选一执行
'''
从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数
'''
num = int(input('输入一个整数'))

# 条件判断
if num % 2 == 0:
    print(num, '是偶数')
else:
    print(num, '是奇数')

if 条件表达式:
  	条件执行体1
elif 条件表达式2:
  	条件执行体2
elif 条件表达式N:
  	条件执行体N
else:
  	条件执行体N+1

'''
多分支结构，多选一执行
从键盘录入一个整数 成绩

90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
小于0或大于100 为非法数据
'''

score = int(input('输入一个成绩：'))
# 判断
if score >= 90 and score <= 100:
    print('A')
elif score >= 80 and score <= 89:
    print('B')
elif score >= 70 and score <= 79:
    print('C')
elif score >= 60 and score <= 69:
    print('D')
elif score >= 0 and score <= 59:
    print('E')
else:
    print('成绩有误，不在成绩的有效范围')

'-----------------写法二------------------'

if 90 <= score <= 100:
    print('A')
elif 80 <= score <= 89:
    print('B')
elif 70 <= score <= 79:
    print('C')
elif 60 <= score <= 69:
    print('D')
elif 0 <= score <= 59:
    print('E')
else:
    print('成绩有误，不在成绩的有效范围')

if 条件表达式:
  	if 内层条件表达式:
      	内层条件执行体1
     else:
        内层条件执行体2
else:
  	条件执行体

'''
会员 >= 200 8折
    >= 100 9折
    不打折
非会员 >=200 9.5折
    不打折
'''
answer = input('会员y/n')
money = float(input('购物金额：'))

# 外层判断是否是会员
if answer == 'y':
    if money >= 200:
        print('打8折，付款金额为：', money * 0.8)
    elif money >= 100:
        print('打9折，付款金额为：', money * 0.9)
    else:
        print('不打折，付款金额为：', money)
else:  # 非会员
    if money >= 200:
        print('打9.5折，付款金额为：', money * 0.95)
    else:
        print('不打折，付款金额为：', money)

x if 判断条件 else y

'''
从键盘录入两个整数，比较大小
'''

num_a = int(input('第一个整数'))
num_b = int(input('第二个整数'))
# 比较大小
'''
if num_a >= num_b:
    print(num_a, '大于等于', num_b)
else:
    print(num_a, '小于', num_b)
'''

print('使用条件表达式进行比较')
print(num_a.__str__() + '大于等于' + num_b.__str__() if num_a >= num_b else num_a.__str__() + '小于' + num_b.__str__())

# pass语句，什么都不做，只是一个占位符，用到需要写语句的地方
answer = input('会员y/n')

# 判断是否是会员
if answer == 'y':
    pass
else:
    pass

# range()的三种创建方式

'''第一种，只有一个参数（小括号中只给了一个数）'''
r = range(10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],默认从0开始，默认相差1称为步长
print(r)  # range(0, 10)
print(list(r))  # 用于查看range对象中的整数序列，list是列表的意思

'''第二种，给了两个参数（小括号中给了两个数）'''
r = range(1, 10)  # 指定了起始值，从1开始，到10结束（不包含10），默认步长为1
print(list(r))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第三种，给了三个参数（小括号中给了三个数）'''
r = range(1, 10, 2)
print(list(r))  # [1, 3, 5, 7, 9]

'''判断指定的整数 在序列中是否存在in， not in'''
print(10 in r)
print(9 in r)

print(10 not in r)
print(9 not in r)

print(range(1, 20, 1))  # [1...19]
print(range(1, 101, 1))  # [1...100]

while 条件表达式
			条件执行体（循环体）

a = 1
# 判断条件表达式
while a < 10:
    # 执行条件执行体
    print(a)
    a += 1

for 变量 in 可迭代对象:
  		循环体

# 遍历字符串
for item in 'Python':
    print(item)

# range()产生一个整数序列，也是一个可迭代对象
for i in range(10):
    print(i)

# 如果在循环体中不需要使用到自定义遍历，可将自定义变量写为"_"
for _ in range(5):
    print('人生苦短，我用Python')

# 使用for循环，计算1到100之间到偶数和
sum = 0  # 用于存储偶数和
for i in range(1, 101):
    if not i % 2:
        sum += i
print(sum)

'''从键盘录入密码，最多录入三次，如果正确就结束循环'''
for item in range(3):
    pwd = input('输入密码：')
    if pwd == '8888':
        print('正确')
        break
    else:
        print('不正确')

a = 0
while a < 3:
    pwd = input('输入密码：')
    if pwd == '8888':
        print('正确')
        break
    else:
        print('不正确')
    a += 1

'''
要求输出1到50之间5的倍数，5，10，15，20，25...
5的倍数的共同点：和5的余数为0的数字都是5的倍数
'''

for item in range(1, 51):
    # 模5等于0取反
    if not item % 5:
        print(item)

print('--------使用continue----------')
for item in range(1,51):
    if item % 5:
        continue
    print(item)

for i in range(3):
    pwd = input('输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('不正确')
else:
    print('三次密码均输入错误')

a = 0
while a < 3:
    pwd = input('输入密码：')
    if pwd == '8888':
        print('正确')
        break
    else:
        print('不正确')
    a += 1
else:
    print('三次密码均输入错误')

a = 10  # 变量存储的是一个对象的引用
lst = ['hello', 'world', 98]
print(id(lst))
print(type(lst))
print(lst)

'''创建列表的第一种方式，使用[]'''
lst = ['hello', 'world', 98]

'''创建列表的第二种方式，使用内置函数list()'''
lst2 = list(['hello', 'world', 98])

'''创建列表的第一种方式，使用[]'''
lst = ['hello', 'world', 98, 'hello']
print(lst)
print(lst[0], lst[-4])

'''创建列表的第二种方式，使用内置函数list()'''
lst2 = list(['hello', 'world', 98])

lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello'))  # 如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
# print(lst.index('Python')) # ValueError: 'Python' is not in list

# lst.index('hello', 1, 3) # ValueError: 'hello' is not in list 从下标为1的索引查找，到3结束，不包括3

print(lst.index('hello', 1, 4))

# 获取索引为2的元素
print(lst[2])
# 获取索引为-3的元素
print(lst[-3])

# 获取索引为10的元素
# print(lst[10]) # IndexError: list index out of range

列表[start:stop:step]

lst = [10, 20, 30, 40, 50, 60, 70, 80]
# start=1,stop=6,step=1
print(lst[1:6:1])
print('原列表', id(lst))
lst2 = lst[1:6:1]
print('切的片段：', id(lst2))

print(lst[1:6])  # 默认步长为1
print(lst[1:6:])
# start=1,stop=6,step=2
print(lst[1:6:2])
# stop=6,step=2, start采用默认
print(lst[:6:2])
# start=1,step=2,stop采用默认
print(lst[1::2])

print('---------step步长为负数的情况----------')
print('原列表', lst)
print(lst[::-1])
# start=7,stop 省略 step=-1
print(lst[7::-1])
# start=6,stop=0,step=-2
print(lst[6:0:-2])

print('---------列表查询操作----------')
lst = [10, 20, 'python', 'hello']
print(10 in lst)  # True
print(100 in lst)  # False
print(10 not in lst)  # False
print(100 not in lst)  # True
for item in lst:
    print(item)

# 向列表的末尾添加一个元素

lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))
lst.append(100)
print('添加元素之后', lst, id(lst))
lst2 = ['hello', 'world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表到末尾
print(lst)

# 向列表到末尾一次性添加多个元素
lst.extend(lst2)
print(lst)

# 在任意位置上添加一个元素
lst.insert(1,90)
print(lst)


lst3=[True,False,'hello']
# 在任意到位置上添加N多个元素，切掉的部分用新列表去替换
lst[1:]=lst3
print(lst)

lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)

# lst.remove(100) # ValueError: list.remove(x): x not in list

# pop()根据索引移除元素
lst.pop(1)
print(lst)
# lst.pop(5) # IndexError: pop index out of range 如果指定的索引不存在，将抛出异常

lst.pop()  # 如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)

'-------切片操作-删除至少一个元素，产生一个新的列表对象-----'
new_lst = lst[1:3]
print('原列表', lst)
print('切片后的列表', new_lst)

'''不产生新的列表对象，而是删除原列表中的内容'''
# 空列表替代
lst[1:3] = []
print(lst)


'''清除列表中的所有元素'''
lst.clear()
print(lst)

'''del语句将列表对象删除'''
del lst
# print(lst) # NameError: name 'lst' is not defined

lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst)
lst[1:3] = [300, 400, 500, 600]
print(lst)

lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))
# 开始排序，调用列表对象的sort方法，升序排序
lst.sort()
print('排序后的列表', lst, id(lst))

# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  # reverse=True表示降序排序，reverse=False就是升序排序
print(lst)
lst.sort(reverse=False)
print(lst)

print('---------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象---------')
lst = [20, 40, 10, 98, 54]
print('原列表', lst, id(lst))
# 开始排序
new_list = sorted(lst)
print(lst, id(lst))
print(new_list, id(new_list))
# 指定关键字参数，实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)

# i*i:表示列表元素的表达式
# i:自定义变量
# range(1,10):可迭代对象
[ i*i for i in range(1,10) ]

lst = [i for i in range(1, 10)]
print(lst)

'''列表中的元素的值为2,4,6,8,10'''
lst2 = [i * 2 for i in range(1, 11)]
print(lst2)

# scores:字典名
# {}:花括号
scores = { '张三': 100,... }

'''字典的创建方式'''
'''使用{}创建字典'''
scores = {
    '张三': 100,
    '李四': 98,
    '王五': 45
}
print(scores)
print(type(scores))

'''创建dict()'''
student = dict(name='jack', age=20)
print(student)

'''空字典'''
d = {}
print(d)

'''获取字典的元素'''
scores = {'张三': 100, '李四': 98, '王五': 45}
'''第一种方式，使用[]'''
print(scores['张三'])
# print(scores['陈六']) # KeyError: '陈六'

'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('陈六'))  # None
print(scores.get('麻七', 99))  # 99是在查找'麻七'所对应对key不存在时，提供对一个默认值

del scores[key]

scores[key]=90

'''key的判断'''
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']  # 删除指定的key-value对
# scores.clear()  # 清空字典的元素
print(scores)

scores['陈六'] = 98  # 新增元素
print(scores)

scores['陈六'] = 100  # 修改元素
print(scores)

scores = {'张三': 100, '李四': 98, '王五': 45}

# 获取所有key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))

# 获取所有的value
values = scores.values()
print(values)
print(type(values))
print(list(values))

# 获取所有的键值对
items = scores.items()
print(items)
print(type(items))
print(list(items)) # 转换之后的列表元素是由元组组成

for item in scores:
  	print(item)

scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
    print(item, scores[item], scores.get(item))

d = {'name': '张三', 'name': '李四'}  # key不允许重复
print(d)

d = {'name': '张三', 'nickname': '张三'}  # value可以重复
print(d)

lst = [10, 20, 30]
lst.insert(1, 100)
print(lst)

d = {lst: 100}  # TypeError: unhashable type: 'list'
print(d)

# item.upper():表示字典key的表达式
# price:表示字典value的表达式
# item,price:自定义表示key，value的变量
# zip(items,prices):可迭代对象
{ item.upper(): price for item,price in zip(items,prices) }

items = ['f', 'b', 'o']
prices = [96, 78, 85, 100, 120]

# 进行压缩的过程中，会以元素少的列表为基准
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)

t = ('Python', 'hello')

'''元组的创建方式'''

'''第一种创建方式，使用()'''
t = ('Python', 'world', 98)
print(t)
print(type(t))
print(type(t) is tuple)

t2 = 'Python', 'world', 98  # 省略了小括号
print(t2)
print(type(t2))

t3 = ('Python',)  # 如果元组中只有一个元素，逗号不能省
print(t3)
print(type(t3))

'''第二种创建方式，使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1)
print(type(t1))

'''空元组的创建方式'''
t4 = ()
t5 = tuple()

'''空列表的创建方式'''
lst = []
lst1 = list()

'''空字典的创建方式'''
d = {}
d2 = dict()

print('空列表', lst, lst1)
print('空字典', d, d2)
print('空元组', t4, t5)

'''元组的遍历'''

t = ('Python', 'world', 98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
'''遍历元组'''
for item in t:
    print(item)

# 集合的创建方式
'''第一种创建方式使用{}'''
s = {2, 3, 4, 5, 5, 6, 7, 7}  # 集合中的元素不允许重复
print(s)

'''第二种创建方式'''
s1 = set(range(6))
print(s1, type(s1))

s2 = set([1, 2, 3, 4, 5, 5, 6, 6])
print(s2, type(s2))

s3 = set((1, 2, 4, 4, 5, 65))  # 集合中的元素是无序的
print(s3, type(s3))

s4 = set('python')
print(s4, type(s4))

s5 = set({12, 4, 34, 55, 66})
print(s5, type(s5))

# 定义一个空集合
s6 = {}  # dict字典类型
print(type(s6))

s7 = set()
print(type(s7))

# 集合的相关操作
s = {10, 20, 30, 405, 60}
print(10 in s)  # True
print(100 in s)  # False
print(10 not in s)  # False
print(100 not in s)  # True

''' 集合元素的新增操作'''
s.add(80) # add一次添加一个元素
print(s)

s.update({200,400,300}) # 一次至少添加一个元素
print(s)

s.update([100,99,8])
s.update((78,64,56))
print(s)


'''集合元素的删除操作'''
s.remove(100)
print(s)

# s.remove(500) # KeyError: 500
s.discard(500)
print(s)

s.pop()
print(s)

s.clear()
print(s)

'''两个集合是否相等（元素相同，就相等）'''

s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False

''' 一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1))  # True
print(s3.issubset(s1))  # False

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))  # True
print(s1.issuperset(s3))  # False

'''两个集合是否没有交集'''
print(s2.isdisjoint(s3))  # False 有交集
s4 = {100, 200, 300}

print(s2.isdisjoint(s4))  # True 没有交集

# 集合的数学操作

# 交集
s1={1,2,3,4}
s2={2,3,4,5,6}
print(s1.intersection(s2))
print(s1 & s2) # intersection()与&等价，交集操作

# 并集操作
print(s1.union(s2))
print(s1 | s2) # union与 | 等价，并集操作
print(s1)
print(s2)

# 差集操作
print(s1.difference(s2))
print(s1 - s2)

# 对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

# i*i表示集合元素的表达式
# i自定义变量
# range(1,10)可迭代对象
{ i*i for i in range(1,10) }

# 列表生成式
lst = [i * i for i in range(6)]
print(lst)

# 集合生成式
s = {i * i for i in range(6)}
print(s)

# 字符串的驻留机制
a = 'Python'
b = "Python"
c = '''Python'''
print(a, id(a))
print(b, id(b))
print(c, id(c))

'''字符串长度为0或1'''
s1 = ''
s2 = ''
print(s1 is s2)  # True
s1 = '%'
s2 = '%'
print(s1 is s2)  # True

'''符合标识符的字符串'''
s1 = 'abc%'
s2 = 'abc%'
print(s1 == s2)  # True
print(s1 is s2)  # False

'''字符串只在编译时进行驻留，而非运行时'''
a = 'abc'
# b的值在运行之前就已经连接完成
b = 'ab' + 'c'
# c的值是在运行时使用join对列表进行连接
c = ''.join(['ab', 'c'])
print(a is b)  # True
print(a is c)  # False

'''[-5,256]之间的整数数字'''
a = -5
b = -5
print(a is b)  # True
a = -6
b = -6
print(a is b)  # False

import sys

a='abc%'
b='abc%'
'''使用sys中对intern方法强制驻留'''
a = sys.intern(b)
print(a is b) # True

# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
print(s.rindex('lo'))  # 9
print(s.rfind('lo'))  # 9

# print(s.index('k')) # ValueError: substring not found
print(s.find('k'))  # -1
# s.rindex('k')
print(s.rfind('k'))

# 字符串中的大小写转换的方法

s='hello,python'
a=s.upper() # 转成大写之后，会产生一个新的字符串对象
print(a, id(a))
print(s, id(s))

b=s.lower()
print(b, id(b))
print(s, id(s))

print(b == s)
print(b is s)

s2='hello,Python'
print(s2.swapcase())

print(s2.title())

print(s2.capitalize())

s='hello,Python'
'''居中对齐'''
print(s.center(20, '*'))

'''左对齐'''
print(s.ljust(20, '*'))
print(s.ljust(10))
print(s.ljust(20))

'''右对齐'''
print(s.rjust(20, '*'))
print(s.rjust(20))
print(s.rjust(10))

'''右对齐，使用0进行填充'''
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))

s='hello world Python'
lst=s.split()
print(lst)

s1='hello|world|Python'
print(s1.split(sep='|',maxsplit=1))
print('---------------')
'''rsplit()从右侧开始拆分'''
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|', maxsplit=1))

s='hello,python'
print(s.isidentifier())
print('hello'.isidentifier())
print('张三_'.isidentifier())
print('张三_123'.isidentifier())

print('\t'.isspace())

print('abc'.isalpha())
print('张三'.isalpha()) # 拼音
print('张三1'.isalpha())

print('123'.isdecimal())
print('123四'.isdecimal())
print('Ⅱ'.isdecimal())

print('123'.isnumeric())
print('123四'.isnumeric())
print('Ⅱ'.isnumeric())

print('abc1'.isalnum())
print('张三123'.isalnum())
print('abc!'.isalnum())

s = 'hello,Python'
print(s.replace('Python', 'java'))
s1='hello,Python,Python,Python'
print(s1.replace('Python', 'java', 2))

lst = ['hello','java','Python']
print('|'.join(lst))
print(''.join(lst))

t=('hello','Java','Python')
print(''.join(t))


print('*'.join('Python'))

print('apple' > 'app')
print('apple' > 'banana')

print(ord('a'), ord('b'))
print(ord('杨'))

print(chr(97), chr(98))
print(chr(26472))

'''
==与is的区别
==比较的是value
is比较的是id是否相等
'''

a=b='Python'
c='Python'
print(a == b)
print(b == c)

# a,b,c指向的是同一块内存空间
print(a is b)
print(a is c)

s = 'hello,Python'

s1 = s[:5]  # 由于没有指定起始位置，所以从0开始切
s2 = s[6:]  # 由于没有指定结束位置，所以切到字符串的最后一个元素
s3 = '!'

new_str = s1 + s3 + s2

print(s1)
print(s2)
print(new_str)

print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(new_str))

print('切片[start:end:step]')
print(s[1:5:1])  # 从1开始截到5（不包括5），步长为1
print(s[::2])  # 默认从0开始，没有写结束，默认到字符串到最后一个元素，步长为2，两个元素之间到索引间隔为2
print(s[::-1])  # 默认从字符串到最后一个元素开始，到字符串到第一个元素结束，因为步长为负数
print(s[-6::1])  # 从索引为-6开始，到字符串到最后一个元素结束，步长为1

# 格式化字符串

# %占位符
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age))

# {}占位符
print('我叫{0},今年{1}岁'.format(name, age))

# f-string
print(f'我叫{name},今年{age}岁')

# 字符宽度
print('%10d' % 99)  # 10表示的是宽度
print('%.3f' % 3.1415926)  # .3表示小数点后三位

# 同时表示宽度和精度
print('%10.3f' % 3.1415926)  # 总宽度为10，小数点后3位

# {}格式化
print('{0:.3}'.format(3.1415926))  # .3表示一共是3位数
print('{:.3f}'.format(3.1415926))  # .3f表示3位小数
print('{:10.3f}'.format(3.1415926))  # .3f表示3位小数，10表示宽度，同时设置宽度和精度

# byte代表一个二进制数据（字节类型的数据）

s = '天涯共此时'
byte=s.encode(encoding='GBK') # 编码
print(byte)
print(byte.decode(encoding='GBK')) # 解码

byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

def 函数名([输入参数]):
  	函数体
    [return xxx]

def calc(a, b):
    c = a + b
    return c

result = calc(10, 20)
print(result)

def calc(a, b):  # a,b称为形式参数，简称形参，形参的位置是在函数的定义处
    c = a + b
    return c


result = calc(10, 20)  # 10,20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)

res = calc(a=10, b=20) # =左侧的变量名称称为关键字参数
print(res)

'''
在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值 arg1修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值 arg2修改.append(10)，会影响到n2点值
'''

def fun(a, b=10):  # b称为默认值参数
    print(a, b)


# 函数的调用
fun(100)
fun(20, 30)

print('hello', end='\t')
print('world')

# 函数定义时的可变的位置参数
def fun(*args):
    print(args)
    # print(args[0])


fun(10)
fun(10, 20, 30)
fun(10, 20, 30, 40)


# 函数定义时的可变的关键字参数
def fun1(**args):
    print(args)


fun1(a=10)
fun1(a=10, b=30, c=40)

'''
def fun2(*args, *a):
    pass
    以上代码，程序会报错，可变的位置参数，只能是一个
def fun2(**arg, **a):
    pass
    以上代码，程序会报错，个数可变的关键字参数，只能是一个
'''

def fun2(*args, **args2):
    pass

'''
def fun3(**args1, *args2):
    pass
    在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参
    要求，个数可变的位置形参，放在个数可变的关键字形参之前
'''

# a,b,c在函数的定义处，所以是形式参数
def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)


'''-------------位置传参---------------'''
# 在函数调用时的参数传递，称为位置传参
fun(10, 20, 30)

# 将列表参数传入
lst = [11, 22, 33]
# 在函数调用时，将列表中的每个元素都转换为位置实参传入
fun(*lst)

'''-------------关键字传参---------------'''
# 关键字实参传入
fun(a=100, c=300, b=200)

# 将字典参数传入
dic = {'a': 111, 'b': 222, 'c': 333}
# 在函数调用时，将字典中的键值对都转换为关键字实参传入
fun(**dic)

'''----------默认值形参------------'''
# b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
def fun(a, b=10):
    print('a=', a)
    print('b=', b)


'''----------个数可变的位置形参------------'''
# 个数可变的位置形参
def fun2(*args):
    print(args)


'''----------个数可变的关键字形参------------'''
# 个数可变的关键字形参
def fun3(**args):
    print(args)


fun2(10, 20, 30)
fun3(a=11, b=22, c=33)

# 从*之后的参数，在函数调用时，只能采用关键字参数传递
def fun4(a, b,*, c, d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)

# 位置实参传递
# fun4(10,20,30,40)
# 关键字实参传递
fun4(a=10,b=2,c=30,d=40)
# 前两个参数，采用的是位置实参传递，而c，d采用的是关键字实参传递
fun4(10,20,c=30,d=40)
# c，d只能采用关键字传递

'''函数定义时的形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass

def fun6(*args, **args2):
    pass

def fun7(a,b=10,*args,**args2):
    pass

def fun(a,b):
    # c，就称为局部变量，因为c是在函数体内进行定义的变量，a,b为函数的形参，作用范围也是函数内部，相当于局部变量
    c = a+b
    print(c)


# 因为a,c超出了起作用的范围（超出了作用域）
# print(c)
# print(a)

# name的作用范围为函数内部和外部都可以使用--称为全局变量
name = '张三'
print(name)

def fun2():
    print(name)

fun2()

def fun3():
    # 函数内部定义的变量，局部变量，使用global声明，这个变量实际上就变成了全局变量
    global age
    age = 20
    print(age)

fun3()
print(age)

def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n - 1)


print(fac(6))

try:
    a = int(input('第一个整数'))
    b = int(input('第二个整数'))
    result = a / b
    print('结果为：', result)
except ZeroDivisionError:
    print('除数不允许为0')
except ValueError:
    print('只能输入数字')

print('程序结束')

try:
    a = int(input('第一个整数'))
    b = int(input('第二个整数'))
    result = a / b
    print('结果为：', result)
except BaseException as e:
    print('出错了', e)
else:
    print('计算结果为：', result)

try:
    a = int(input('第一个整数'))
    b = int(input('第二个整数'))
    result = a / b
    print('结果为：', result)
except BaseException as e:
    print('出错了', e)
else:
    print('计算结果为：', result)
finally:
    print('谢谢使用')

import traceback

try:
    print('------------')
    num = 10 / 0
except:
    traceback.print_exc()

class Student:
  pass

# Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
class Student:
    native_pace = '吉林' # 直接写在类里的变量，称为类属性

    def __init__(self, name, age):
        # self.name 称为实例属性，进行类一个赋值的操作，将局部变量的name的值赋给实例属性
        self.name = name
        self.age = age

    # 实例方法
    def eat(self):
        print('学生在吃饭...')

    # 静态方法
    @staticmethod
    def method():
        print('静态方法')

    @classmethod
    def cm(cls):
        print('类方法')


# 在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

print(id(Student))
print(type(Student))
print(Student)

# Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
class Student:
    native_pace = '吉林' # 直接写在类里的变量，称为类属性

    def __init__(self, name, age):
        # self.name 称为实例属性，进行类一个赋值的操作，将局部变量的name的值赋给实例属性
        self.name = name
        self.age = age

    # 实例方法
    def eat(self):
        print('学生在吃饭...')

    # 静态方法
    @staticmethod
    def method():
        print('静态方法')

    @classmethod
    def cm(cls):
        print('类方法')


# 在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

print(id(Student))
print(type(Student))
print(Student)
print('-----------------')
# 创建Student对象
stu1 = Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)
print(id(stu1))
print(type(stu1))
print(stu1)

print('-----------------')
Student.eat(stu1)

# Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
class Student:
    native_pace = '吉林' # 直接写在类里的变量，称为类属性

    def __init__(self, name, age):
        # self.name 称为实例属性，进行类一个赋值的操作，将局部变量的name的值赋给实例属性
        self.name = name
        self.age = age

    # 实例方法
    def eat(self):
        print('学生在吃饭...')

    # 静态方法
    @staticmethod
    def method():
        print('静态方法')

    @classmethod
    def cm(cls):
        print('类方法')


print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',20)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'

print(stu1.native_pace)
print(stu2.native_pace)

print('类方法的使用方式')
Student.cm()
print('静态方法的使用方式')
Student.method()

class Student:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '在吃饭...')


stu1 = Student('张三', 20)
stu2 = Student('李四', 20)
print(id(stu1))
print(id(stu2))
print('为stu2动态绑定属性')
stu2.gender = '女'
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)

stu1.eat()
stu2.eat()


def show():
    print('调用了show')


stu1.show = show
stu1.show()

# stu2.show() # 因为stu2没有绑定show方法