学习python

# 开发人员: hanhan丶

# 开发时间: 2020/10/21 14:37

#######################################################################################################

# 将数据输出到文件中

# fp = open('D:/test.txt','a+')  # a+(没有这个文件的情况下创建这个文件,如果存在就在文件中继续添加)

# print('123',file=fp)

# fp.close()

#######################################################################################################

# 转义字符

# print('hello\nworld')  # \n换行打印

# print('hello\tworld')  # \t代表4组空格

# print('hello\rworld')  # \r之前的全删掉，输出world

# print('hello\bworld')  # \b代表退一格，输出hellworld

# print('大家好:\'我是py\'')  # 单引号中输出单引号

#######################################################################################################

# 原字符 （不希望专业字符起作用，就使用原字符，在字符串前加上r或R  !!!最后一个字符不能是“\”）

# print(r'hello\nworld')

# print(R'hello\nworld')

#######################################################################################################

# 2进制  计算机只识别2进制  一共有2，8，10，16

# print(chr(0b100111001011000))  # 0b代表2进制

# print(ord('乘'))  # ord()转化成10进制

# print(0o777)  # 10进制

# print(0x1EAF)  # 16进制

#######################################################################################################

# 关键字

# import keyword

# print(keyword.kwlist)  # 输出所有关键字

#######################################################################################################

# 浮点数  （因计算机是2进制，浮点数计算可能不准确，可以使用一下方法）

# from decimal import Decimal

# print(Decimal('1.1')+Decimal('2.2'))

#######################################################################################################

# str 和 int 之间的类型转换

# name = 'xuhan'

# age = 18

# print('my name is' + name + ' ' + 'my age is' + ' ' + str(age))

#######################################################################################################

# input()

# a = input('请输入加数')

# b = input('请输入另一个加数')

# print(int(a)+int(b))

#######################################################################################################

# is is not

# a = 10

# b = 10

# print(a == b)  # 是在比较value

# print(a is b)  # 是在比较id

# print(a is not b)  # a的id和b的id是不相等的吗

#######################################################################################################

# and or not

# a = 1

# b = 2

# c = True

# d = False

# print(a==1 and b==2)

# print(a==1 and b!=2)

# print(a==1 or b==2)

# print(a==1 or b!=2)

# print(not c)

# print(not d)

#######################################################################################################

# in  not in

# a = 'abcd'

# print('a' in a)

# print('f' in a)

# print('a' not in a)

# print('f' not in a)

#######################################################################################################

# 位运算符

# print(4&8)  # 按位与& 同为1时结果为1

# print(4|8)  # 按位或| 同为0时结果为0

# print(4<<1)  # 向左移动一位（移动一个位置），相当于乘以2

# print(4<<2)  # 向左移动两位（移动两个位置），相当于乘以4

# print(4>>1)  # 向右移动一位（移动一个位置），相当于除以2

# print(4>>2)  # 向右移动两位（移动两个位置），相当于除以4

#######################################################################################################

# if elif else  (多分支结构)

# num = int(input("请输入金额"))

# if 90<=num<=100:

#    print('A')

# elif 80<=num<=89:

#    print('B')

# else:

#    print('C')

##########################

# if num < 0 or num > 100:

#    print('非法数字')

# elif num <= 59:

#    print('不及格')

# else:

#    print('及格')

# identity = input('您是会员吗？y/n')

# num = int(input('输入消费金额'))

# if identity == 'y':

#    if 100 <= num <= 200:

#        input('ziyuanma')

#        print('打8折')

#    elif 0 <= num <= 99:

#        print('打9折')

# elif identity == 'n':

#    print('非会员')

#######################################################################################################

# 条件表达式

# a = int(input('输入a'))

# b = int(input('输入b'))

# print(str(a) + '大于等于' + str(b) if a >= b else str(a) + '小于' + str(b))

#######################################################################################################

# pass语句，什么都不做只是一个占位符，用到需要写语句的地方

# a = input('您是会员吗？y/n')

# if a == "y":

#    pass

# else:

#    pass

#######################################################################################################

# range()的三种创建方式

# 1.第一种创建方式，只有一个参数（小括号中只有一个数）

# r = range(10)        # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 默认从0开始，默认相差1，称为步长

# print(r)            # range(0, 10)

# print(list(r))      # 用于查看range函数中的整数序列，

# 2.第二种创建方式，有两个参数

# r = range(1,5)        # 指定了从1开始到5，但不包含5，默认步长为1

# print(r)              # range(1, 5)

# print(list(r))        # [1, 2, 3, 4]

# 第三种创建方式，有三个参数

# r = range(1, 10, 2)  # 第一个参数是起始位置，第二个参数是结束位置但不包含，第三个是步长

# print(list(r))  # [1, 3, 5, 7, 9]

# print(8 in r)  # False

#######################################################################################################

# 判断条件表达式  while循环

# a = 1

# while a <= 4:

#    print(a)

#    a += a

#######################################################################################################

# 求0-4之间的累加和

# num = 0

# a = 0

# while a <= 4:

#    num += a

#    a += 1

# print(num)

#######################################################################################################

# 求1-100之间的偶数和

# num = 0

# a = 0

# while a <= 100:

#    if not bool(a % 2):    # 因为a%2是fasle，not 就是取不是false的就是true的

#        num += a

#    a += 1

# print(num)

#######################################################################################################

# 求0-100奇数的和

# num = 0

# a = 0

# while a <= 100:

#    if a % 2:  # 这个等于 a%2==0  因为0就是false  false就进入判断中

#        num += a

#    a += 1

# print(num)

#######################################################################################################

# for in 循环

# for item in 'xuhan':

#    print(item)

# for i in range(10):

#    print(i)

# for _ in range(10):    # 当你不需要打印每一次的值的时候，可以用 _ 来表示

#    print('小徐最帅啦')

#######################################################################################################

# 使用for循环计算0-100的偶数累加和

# num = 0

# for item in range(1, 101):

#    if not bool(item % 2):

#        num += item

# print(num)

#######################################################################################################

# 使用for循环算数0-100基数的和

# num = 0

# for item in range(1,101):

#    if bool(item%2):

#        num+=item

# print(num)

#######################################################################################################

# 使用for循环算出100-999之间的水仙花数

# num = 0

# for item in range(100, 1000):

#    ge = item % 10  # 个位

#    shi = item // 10 % 10  # 十位

#    bai = item // 100  # 百位

#    if ge ** 3 + shi ** 3 + bai ** 3 == item:

#        num += item

#    item += 1

# print(num)

#######################################################################################################

# 流程控制语句break

# 从键盘录入密码，最多3次，正确结束循环

# num = 3

# for item in range(1, 4):

#    b = input('请输入密码')

#    if b == '3':

#        print('输入正确')

#        break

#    else:

#        num -= 1

#        print('输入错误请重试,还剩余' + str(num) + '次')

#######################################################################################################

# while循环执行上面的需求

# a = 0

# while a < 3:

#    b = input('请输入密码')

#    if b=='3':

#        print('登陆成功')

#        break

#    else:

#        print('密码错误')

#    a += 1

#######################################################################################################

# continue语句 用于结束当前循环，执行下一次循环，通常与分支中的if一起使用

# 要求算数0-50之间所有5的倍数 使用continue

# for item in range(1, 51):

#    if bool(item % 5):

#        continue

#    print(item)

#######################################################################################################

# for 中的 else  while中的else同理

# for item in range(3):

#    b = input('请输入密码')

#    if b == '3':

#        print('输入正确')

#        break

#    else:

#        print('密码不正确')

# else:

#    print('3次机会已经用完')

#######################################################################################################

# 输出一个三行四列的矩形

# for item in range(3):

#    for test in range(4):

#        print('*',end="\t")    # 不换行输出

#    print() # 换行

#######################################################################################################

# 制作一个99乘法表

# for i in range(1,10):            # 外行控制的是行数

#    for j in range(1,i+1):        # 内行控制的是打印的个数

#        print(str(j),'*',str(i),'=',j*i,end="\t")

#    print()

#######################################################################################################

# 二重循环中的break和contiune 只会对本层的循环有影响对外层的循环没有影响

# for i in range(5):

#    for j in range(1,11):

#        if j % 2 == 0:

#              #break

# continue

# print(j, end="\t")

# print()

#######################################################################################################

# 列表list

# arr = ['a',1,'b',2,1,9]

# print(arr.index(1,2,5))  # 查找一个数组中有相同元素的方法

# print(arr.index(1))    # 若列表中有多个相同元素，只会返回第一个元素所在的索引

# print(arr)

# print(arr[0])

# print(arr[-4])

#######################################################################################################

# 列表切片

# arr = [10, 20, 30, 40, 50, 60, 70, 80]

# print(arr[1:6:1])      # start:end:步长，返回新数组 1是索引，6也是索引，到6停止但不包含6，1为步长

# print(arr[::-1])        # start和end默认的情况和步长为-1时，数组倒序

# print(arr[1:0:-1])        # 输出结果[20] 从索引1开始，步长为一往回走，到索引为0但是不包含0，就只剩20

#######################################################################################################

# 列表中的 in，not in

# arr = [1,'2',3]

# print(1 in arr)        # True

# print(2 in arr)        # False

# print(1 not in arr)    # False

# print(2 not in arr)    # True

#######################################################################################################

# 列表中的遍历  for in 循环

# arr = [1,'2',3,'4']

# for item in arr:

#    print(type(item))

#######################################################################################################

# 列表元素的增加操作

# 1.append() 在列表末尾添加一元素

# 2.extend() 在列表末尾至少添加一个元素

# 3.insert() 在列表的任意位置添加一个元素

# 4.切片      在列表任意位置添加至少一个元素

# arr = [1,2,3,4]

# arr2 = [5,6]

# arr.append(arr2)    # 不返回新数组  [1, 2, 3, 4, [5, 6]]    !!!常用!!!

# arr.extend(arr2)    #  [1, 2, 3, 4, 5, 6]

# arr.insert(1,1.5)  #  [1, 1.5, 2, 3, 4]  1是索引，1.5是插入的值

# arr[1:] = arr2      #  [1, 5, 6]  1是索引，把原数组的1之后的删掉，把新数组的内容添加进去

# print(arr)

#######################################################################################################

# 列表元素的删除操作

# 1.remove() 一次删除一个元素，重复元素只删除第一个，元素不存在抛出valueError

# 2.pop()    删除一个指定索引位置上的元素，指定索引不存在就抛出IndexError，不指定索引删除列表中最后一个元素

# 3.切片      一次最少删除一个元素，返回新数组

# 4.clear()  清空列表

# 5.del      删除列表

# arr = [1,2,3,4,1,5]

# arr.remove(1)      # 只删除第一个1 [2,3,4,1,5]

# arr.pop(1)        # 根据索引删除[1, 3, 4, 1, 5]

# arr2 = arr[1:3]    # 返回新的数组 [2, 3] 返回的是切掉的内容

# print(arr2)

# arr[1:3] = []      # 不返回新列表的方法[1, 4, 1, 5]

# arr.clear()        # 清空整个列表[]

# del arr            # 删除整个列表NameError: name 'arr' is not defined

# print(arr)

#######################################################################################################

# 列表元素的修改操作

# arr = [1,2,3,4,5]

# arr[1] = 6      # [1, 6, 3, 4, 5]

# arr[1:3] = [9,5.5,8.032,'a']    # [1, 9, 5.5, 8.032, 'a', 4, 5]

# print(arr)

#######################################################################################################

# 列表元素的排序操作

# arr = [1,3.9,5,6,2,4,3,3.4,0.3]

# 1.sort()  列表排序方法，默认升序排序 不返回新数组。revrese=Ture降序排序

# 2.sorted()  内置函数，产生新的数组

# 区别：sort()对远列表进行排序，sorted()对新列表进行排序

# arr.sort()                # [0.3, 1, 2, 3, 3.4, 3.9, 4, 5, 6]

# arr.sort(reverse=True)    # [6, 5, 4, 3.9, 3.4, 3, 2, 1, 0.3] reverse=False就是升序排序

# arr2 = sorted(arr)        # [0.3, 1, 2, 3, 3.4, 3.9, 4, 5, 6]

# arr2 = sorted(arr,reverse=True)  # [6, 5, 4, 3.9, 3.4, 3, 2, 1, 0.3]

# print(arr2)

#######################################################################################################

# 列表生成式（ 生成列表的公式）

# arr = [item for item in range(1,10)]    # 最终列表存储的是i

# print(arr)          # [1, 2, 3, 4, 5, 6, 7, 8, 9]

#  生成列表为2，4，6，8，10

# arr = [i for i in range(2,11,2)]

# arr = [i*2 for i in range(1,6) ]

# print(arr)

#######################################################################################################

# 字典的创建

# obj = {                        # key值必须用引号引起来

#    'a':'12',

#    'b':13

# }

# obj = dict(name='xuhan', age=12)  # key值必须不加引号

# print(obj)

#######################################################################################################

# 字典中获取数据

# 1.[]

# 2.get()

# 区别：当找一个对象中不存在的key值的时候，【】会返回KeyError,get()会返回None，输入默认值的话，会返回默认值

# dict = {

#    'name':'xuhan',

#    'age':18

# }

# print(dict['name'])  # 必须加上引号xuhan

# dict = dict(name='xuhan',age=16)

# print(dict['age'])      # 必须加引号16

# print(dict.get('name'))  # 必须加引号xuhan

# print(dict.get('gender','没找到但是我默认是男'))    # 当没有找到查找的key值的时候，返回默认值

#######################################################################################################

# key 的判断

# dict = dict(name='xuhan', age=16)

# print('name' in dict)            # True

# print('name' not in dict)        # False

# 字典元素的删除

# dict = dict(name='xuhan', age=16)

# del dict['name']      # {'age': 16} 删除指定的键值对 key：value

# dict.clear()          # {} 清空字典

# print(dict)

# 字典元素的新值

# dict = dict(name='xuhan', age=16)

# dict['gender'] = '男'

# print(dict)

# 字典元素的修改

# dict = dict(name='xuhan', age=16)

# dict['name']='xuhan23'

# print(dict)

# 获取字典视图的3个方式

# dict = dict(name='xuhan', age=16)

# print(dict.keys())      # dict_keys(['name', 'age'])    type为dict_keys

# print(dict.values())    # dict_values(['xuhan', 16])    type为dict_values

# print(dict.items())    # dict_items([('name', 'xuhan'), ('age', 16)])    type为dict_items

# 字典元素的遍历

# dict = dict(name='xuhan', age=16)

# for i in dict:

# print(i)    # name age

# print(dict[i]) # xuhan 16

# print(dict.get(i)) # xuhan 16

# 字典生成式

# obj = ['name', 'age', 'gender']

# val = ['xuhan', 18, '男']

# dict = {obj.upper(): val for obj, val in zip(obj, val)}    # {'NAME': 'xuhan', 'AGE': 18, 'GENDER': '男'} upper()变大写  zip()打包压缩

# print(dict)

#######################################################################################################

# 不可变序列和可变序列

# 可变序列 列表 字典  内存地址不会更改

# arr = [1,2,3]

# print(id(arr))    # 2084900910528

# arr.append(4)

# print(id(arr))    # 2084900910528

# 不可变序列 字符串 元组  内存地址发生更改

# font = 'ni'

# print(id(font))    # 1640823668336

# font = font + 'hao'

# print(id(font))    # 1640824975792

#######################################################################################################

# 元组

# 创建元组

# a = (1,2,'3',4.4)  # 第一种创建方式，使用()

# a = tuple((4, 5, '6', 7.7))  # 第二种创建方式，使用内置函数tuple()

# a = (1,)        # 若括号中只有一个数据的时候，结尾必须加上逗号

# print(a)

#######################################################################################################

# 元组为什么是不可变的

# tuple = (1,[2,3],4)

# tuple[1] = 5    # TypeError: 'tuple' object does not support item assignment

# tuple[1].append(6)    # (1, [2, 3, 6], 4) 可以append因为列表是可变的，但是不能修改元组，元组是不可变的

# print(tuple)

#######################################################################################################

# 元组的遍历

# tuple = (1,23,56,8)

# for item in tuple:

#    print(item)

#######################################################################################################

# 集合  可变类型序列 无序的，经过hash模式

# 集合的创建方式

# a = {1,2,3,1,2,3}    # 使用{}创建，只有key，没有value  {1, 2, 3}  自动过滤重复的元素  无序

# a = set(range(6))      # 使用set()内置函数创建    {0, 1, 2, 3, 4, 5}  自动过滤重复的元素  无序

# a = set([1,1,2,2,3,3])    # {1, 2, 3}  可以将列表中的元素转化成集合中的元素  自动过滤重复的元素  无序

# a = set((1,1,2,2,3,3,4))    # {1, 2, 3, 4}  可以将元组中的元素转化成集合中的元素  自动过滤重复的元素  无序

# a = set('helloeeee world')    # {' ', 'w', 'o', 'l', 'd', 'r', 'e', 'h'} 可以将字符串中的元素转化成集合中的元素  自动过滤重复的元素  无序

# a = set({1,2,3,1,2,3})    # {1, 2, 3}

# print(a)    # {1, 2, 3} 集合中的元素不可以重复

#######################################################################################################

# 定义一个空集合

# a = set()

# print(type(a))    #

#######################################################################################################

# 集合元素的判断操作in not in

# a = {1,3,5,7,9}

# print(1 in a)

# print(1 not in a)

# print(2 in a)

# print(2 not in a)

#######################################################################################################

# 集合元素的新增操作add() update()

# a = {1,2,3,4,5,6}

# a.add(1.7)    # {1, 2, 3, 4, 5, 6, 1.7}  添加一个

# a.update({1,6,9})  # {1, 2, 3, 4, 5, 6, 9}  自动过滤重复的元素 列表 元组都可以添加  添加多个

# a.update('123',[8.6,5.2],(789,'da'))    # {1, 2, 3, 4, 5, 6, '1', 8.6, '2', 5.2, 789, 'da', '3'}

# a.update(560)    # TypeError: 'int' object is not iterable

# print(a)

#######################################################################################################

# 集合元素的删除操作

# 1.remove()一次删除一个指定元素

# 2.discard()一次删除一个指定元素

# 3.pop()一次只删除第一个元素

# 4.clear()清空集合

# a = {1,2,3,4,5,6}

# a.remove(2)    # {1, 3, 4, 5, 6}

# a.remove(7)    # KeyError: 7  没有这个元素会抛出异常

# a.discard(5)    # {1, 2, 3, 4, 6}

# a.discard(7)    # {1, 2, 3, 4, 5, 6}  没有这个元素不会抛出异常

# a.pop()      # {2, 3, 4, 5, 6} 只能删除第一个元素，不能添加参数

# a.clear()    # set()

# print(a)

#######################################################################################################

# 集合间的关系

# 判断两个集合是否相等

# a = {1, 2, 3, 5, 8}

# b = {2, 3, 8, 5, 1}

# print(a==b)    #  True 因为序列是无序的

# print(a!=b)    # False

#######################################################################################################

# 判断一个集合是否是另一个集合的子集

# a = {1,2,3,4,5,6}

# b = {2,5,1}

# c = {1,2,4,9}

# print(b.issubset(a))    # True

# print(c.issubset(a))    # False

#######################################################################################################

# 判断一个集合是否是另一个集合的超集

# a = {1,2,3,4,5,6}

# b = {2,5,1}

# c = {1,2,4,9}

# print(a.issuperset(b))  # True

# print(a.issuperset(c))  # False

#######################################################################################################

# 判断两个集合是否没有交集

# a = {1,2,3,4,5,6}

# b = {2,5,1}

# c = {98,8,7}

# print(a.isdisjoint(b))  # False  语法意思是是否没有交集 返回False就是有交集

# print(c.isdisjoint(a))  # True  返回True就是没有交集

#######################################################################################################

# 集合的数学操作

# 1.交集

# a = {1,2,3}

# b = {2,3,4}

# print(a.intersection(b))    # {2, 3}

# print(a & b)    # {2, 3} "&" 求交集的符号

# 2.并集

# a = {1,2,3}

# b = {2,3,4}

# print(a.union(b))  # {1, 2, 3, 4}

# print(a | b)    # {1, 2, 3, 4}  "|" 求并集的符号

# 3.差集

# a = {1, 2, 3}

# b = {2, 3, 4}

# print(a.difference(b))  # {1}

# print(b.difference(a))  # {4}

# print(a - b)  # "-" 求差集的符号

# print(b - a)

# 4.对称差集

# a = {1, 2, 3}

# b = {2, 3, 4}

# print(a.symmetric_difference(b))  # {1, 4}

# print(b.symmetric_difference(a))  # {1, 4}

# print(a ^ b)  # {1, 4}  "^" 求对称差集的符号

#######################################################################################################

# 集合生成式

# a = {1,2,3}

# b = { i for i in range(6)}

# print(type(b))    # 无序的 ！！！！

#######################################################################################################

# 字符串的创建与驻留机制

# a = 'a'

# b = 'a'

# c = 'a'

# print(id(a))  # 2247003362736

# print(id(b))  # 2247003362736

# print(id(c))  # 2247003362736

#######################################################################################################

# 字符串的查询

# a = 'abcdefgabcdefg'

# print(a.index('q'))  # 查到字符串第一次出现的位置 如果没有返回ValueError: substring not found

# print(a.find('q'))  # 查到字符串第一次出现的位置 如果没有返回-1

# print(a.rindex('b'))  # 8 查到字符串最后一次出现的位置 如果没有返回ValueError: substring not found

# print(a.rfind('b'))  # 8 查到字符串最后一次出现的位置 如果没有返回-1

#######################################################################################################

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

# 1.upper()转成大写

# 2.lower()转成小写

# 3.swapcase()把所有大写的元素转换成小写的，把所有小写的转化成大写的

# 4.title()把每个单词的首字符变成大写，其余的变成小写

# 5.capitalize()把一个字符转换成大写其余转换成小写

# a = 'abcdefgabcdefg'

# c = 'AbCdEfG'

# d = 'adSDl Adas lDF'

# b = a.upper()  # 转成大写之后会产生一个新的字符串对象

# print(a)    # abcdefgabcdefg

# print(b)    # ABCDEFGABCDEFG

# print(b.lower())    # abcdefgabcdefg 转成小写之后会产生一个新的字符串对象

# s = c.swapcase()  # 把所有大写的元素转换成小写的，把所有小写的转化成大写的

# print(s)    # aBcDeFg

# x = d.title()  # 把每个单词的首字符变成大写，其余的变成小写

# print(x)    # Adsdl Adas Ldf

# j = d.capitalize()    # 把一个字符转换成大写其余转换成小写

# print(j)  # Adsdl adas ldf

#######################################################################################################

# 字符串内容对齐的方法

# 1.center()居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置的宽度小于实际宽度则返回原字符串

# 2.ljust()左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置的宽度小于实际宽度则返回原字符串

# 3.rjust()右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置的宽度小于实际宽度则返回原字符串

# 4.zfill()右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的参数，如果设置的宽度小于实际宽度则返回原字符串

# a = 'hello world'

# print(a.center(20,'*'))  # ****hello world*****  字符串长度是11，用（20-11）/2就是两边各占的字符

# print(a.ljust(20,'*'))  # hello world*********    全部填充到右边

# print(a.rjust(20,'*'))  # *********hello world    全部填充到左边

# print(a.zfill(20))      # 000000000hello world

# print('-8989'.zfill(8))  # -0008989  会加在-号的后面，算上-号一共8位

#######################################################################################################

# 字符串劈分操作

# 1.split()从字符串左侧开始劈分，默认劈分空格，返回的值是一个列表，通过参数sep指定分隔符，

# 通过参数maxsplit指定劈分字符串时最大的劈分次数，经过最大的劈分之后，剩余的字符串都会单独作为一部分。

# 2.rsplit()从字符串右侧开始劈分，默认劈分空格，返回的值是一个列表，通过参数sep指定分隔符，

# # 通过参数maxsplit指定劈分字符串时最大的劈分次数，经过最大的劈分之后，剩余的字符串都会单独作为一部分。

# a = 'name xuhan age 18'

# b = a.rsplit()  # ['name', 'xuhan', 'age', '18']

# print(b)

# b = a.split()    # ['name', 'xuhan', 'age', '18']

# print(b)

# a = 'name$xuhan$age$18'

# b = a.split(sep='$')    # ['name', 'xuhan', 'age', '18'] sep="" 确定分割符

# b = a.split(sep="$",maxsplit=1)    # ['name', 'xuhan$age$18'] maxsplit分割的段数

# print(b)

#######################################################################################################

# 判断字符串操作方法

# 1.isidentifier()判断是不是合法的字符串

# 2. isspace()判断指定的字符串是否全部由空白字符组成(回车，换行，水平制表符)

# 3. isalpha()判断指定的字符串是否全由字母组成

# 4. isdecimal()判断指定的字符串是否全部由十进制的数字组成

# 5. isnumeric()判断指定的字符串是否全部数字组成

# 6. isalnum()判断指定的字符串是否全部由字母和数字组成

# print('我爱你abc123_'.isidentifier())  # True

# print('\t'.isspace())  # True

# print('asd123'.isalpha())  # False

# print('徐晗'.isalpha())  # True

# print('452'.isdecimal())  # True

# print('1237891223'.isnumeric())  # True

# print('12378一二'.isnumeric())  # True

# print('12378一二'.isalnum())  # True

# print('1237!8一二'.isalnum())  # False

#######################################################################################################

# 字符串操作的其他方法

# 1.replace() 第一个参数是你要替换谁，第二个参数是你要替换后的内容，第三个参数是设定替换的次数

# 2.join()将列表或元组中的的字符串合并为一个字符串

# a = 'hello xuhan'

# print(a.replace('hello','zuishuai'))  # zuishuai xuhan

# print(a.replace('xu','han'))  # hello hanhan

# b = 'xu han han han'

# print(b.replace('han','6',2))  # xu 6 6 han

# list = ['123','456']

# a = ('dasd','xuhan')

# print(''.join(list))  # 123456

# print('@'.join(list))  # 123@456

# print('*'.join(a))  # dasd*xuhan

# print('^'.join('xuhanzuishuaila'))  # x^u^h^a^n^z^u^i^s^h^u^a^i^l^a

#######################################################################################################

# 字符串的比较操作

# 1.运算符>,>=,<,<=,==,!=  ord是查看原始值的，也就是原始值的比较 chr是用原始值查看本身值的，ord的反转

# 2.==和is的区别  ==比较的是值是否相等 is比较的是id是否相等

# print('old'>'older')  # False

# print('red'>'green')  # 114>103 True

# print(ord('r'),ord('g'))  # 114 103

# print(chr(97),chr(98))  # a b 97就是a的原时值，98就是b的原始值

# print(ord('徐'))  # 24464

# print(ord('晗'))  # 26199

# print(chr(24464),chr(26199))  # 徐 晗

# a = b = 'xuhan'

# c = 'xuhan'

# print(a==b)  # True

# print(a==c)  # True

# print(b==c)  # True

# print(a is b)  # True

# print(a is c)  # True

# print(b is c)  # True

# print(id(a))  # 1896614936304

# print(id(b))  # 1896614936304

# print(id(c))  # 1896614936304

#######################################################################################################

# 字符串的切片操作

# 字符串是不可变的类型，不具备增，删，改等操作，切片操作将产生新的对象

# a = 'hello,china'

# b = a[:5]

# c = a[6:]

# d = b + '&' + c

# print(d)  # hello&china

# print(a[1:5:2])  # el

# print(a[::2])  # hlocia是0 2 4 6 8 10怎么结的，步长为2，间隔就是1

# print(a[::1]) # hello,china,步长为1间隔就是0

# print(a[::-1])  # anihc,olleh  元素倒置

# print(a[-5:])  # china

#######################################################################################################

# 格式化字符串

# 1.%占位符

# 2.{}占位符

# 3.f-string占位符

# name = '徐晗'

# age = 18

# gender = '男'

# print('我叫%s,今年%d' % (name,age))  # 只能用%s和%d  我叫徐晗,今年18

# print('我叫{0}，今年{1}，性别{2}'.format(name,age,gender))  # 我叫徐晗，今年18，性别男  {0}代表的索引

# print(f'我叫{name}，今年{age}，性别{gender}')  # 我叫徐晗，今年18，性别男

# print('%7d' % 7)  # '      7' 7代表宽度  总宽度是7

# print('%.2f' %  3.982)  # 3.98，f代表小数，.2代表要保留2位小数

# print('%9.2f' % 8.63214)  # '    8.63' 同时加宽度和保留小数的方法  总宽度是9，保留3位小数

# print('{0:.3}'.format(3.1415926))  # 3.14  .3表示的是一共输出3位数 0是占位符

# print('{0:.3f}'.format(3.1415926))  # 3.142  .3f表示的是保留3位小数  0是占位符

# print('{0:10.3f}'.format(3.1415926))  # ’    3.142‘  .3f表示的是保留3位小数  0是占位符 10代表一共占10位

#######################################################################################################

# 字符串的编码转换

# 编码

# s = '海上升明月'

# print(s.encode(encoding='GBK'))  # 在GBK这种模式中 一个中文占两个字节  b'\xba\xa3\xc9\xcf\xc9\xfd\xc3\xf7\xd4\xc2'  b表示2进制，后面表示1个字占两个字符

# print(s.encode(encoding='UTF-8')) # 在UTF-8这种模式中 一个中文占三个字节b'\xe6\xb5\xb7\xe4\xb8\x8a\xe5\x8d\x87\xe6\x98\x8e\xe6\x9c\x88'

# 解码

# a = '我本将心向明月，可耐明月照沟渠'

# b = a.encode(encoding='GBK')

# print(b.decode(encoding='GBK'))  # 我本将心向明月，可耐明月照沟渠

# b = a.encode(encoding='UTF-8')

# print(b.decode(encoding='UTF-8'))  # 我本将心向明月，可耐明月照沟渠

#######################################################################################################

# 函数的创建和调用

# def fun(a,b):

#    c = a+b

#    return c

# cale = fun(1,2)

# print(cale)

#######################################################################################################

# 函数的参数传递

# 1.顺序传参

# 2.关键字传参

# def fun(a,b):

#    c = a+b

#    return c

# func = fun(3,6)

# print(func)

# def fun(a,b):

#    c = a+b

#    return c

# func = fun(b=8,a=6)  # a:6 b:8  # 只有在调用的时候赋值才是关键字传参

# print(func)

#######################################################################################################

# 函数的返回值

# 1.如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据），return可以省略不写

# 2.函数的返回值如果是1，直接返回原类型（是列表就返回列表是元组就返回元组）

# 3.函数的返回值如果是多个，返回的类型是一个元组

# 用函数写一个100以内返回奇数偶数的方法

# def fun(num):

#    event = []

#    odd = []

#    for i in num:

#        if i%2==0:

#            event.append(i)

#        else:

#            odd.append(i)

#    return event,odd

# a = fun(range(0,101))

# print(a)

# 没有返回值的情况

# def fun():

#    print('你今天有点怪啊')

# fun()

# 返回值为1的

# def fun(a):

#    a.append(5)

#    return a

# b = fun([4,3])    # [4, 3, 5]

# print(b)

# a = input('lol')

# if a=='1':

#    print('True')

# else:

#    print('false')

# 函数参数定义

# 1.个数可变的位置参数

# 2.个数可变的关键字参数

# def fun(*res):  # 函数定义时 可变的位置参数

#    print(res)

# fun(10)    # (10,)

# fun(10,50)    # (10, 50)

# fun(10,50,80)    # (10, 50, 80)

# def fun(**res):

#    print(res)

# fun(a=1,b=2)    # {'a': 1, 'b': 2}

# fun(a=3)    # {'a': 3}

# fun(a="77",b=3.1415,c=range(0,1))    # {'a': '77', 'b': 3.1415, 'c': range(0, 1)}

# 变量的作用域

# def fun():

#    global age    # 函数内部定义的变量，使用global声明之后就变成了全局变量

#    age = 18

#    print(age)

# fun()

# 递归函数

# def fun(n):

#    if n == 1:

#        return 1

#    else:

#        return n * fun(n-1)

#

# print(fun(7))

# 递归实现斐波那契数列

# def fun(n):

#    if n==1:

#        return 1

#    elif n==2:

#        return 1

#    else:

#        res = fun(n-1)+fun(n-2)

#        return res

# # print(fun(6))    # 8

# for i in range(1,7):

#    print(fun(i))  # 1 1 2 3 5 8

#######################################################################################################

# 练习

# age = input('请输入您的真实年龄')

# if age >= '18':

#    print('你成年了')

# else:

#    print('未成年')

# for i in range(3):

#    name = input('用户名')

#    password = input('密码')

#    if name == 'xuhan' and password == '123':

#        print('success')

#        break

#    else:

#        print('Error')

# else:

#    print('3ci')

# arr = [

#    {'name': '张三丰', 'age': 108, 'gender': '女'},

#    {'name': ['张无忌','a'], 'age': 6, 'gender': '男'},

#    {'name': ['张宇航', 'a'], 'age': 18, 'gender': '男'}

# ]

# answer = input('请输入你要搜索的内容')

# for item in arr:

#    nameArr = item['name']

#    if answer in nameArr:

#        print(answer, '的年龄是', item['age'])

#######################################################################################################

# try except

# try:

#    a = int(input('请输入一个整数'))

#    b = int(input('请输入一个整数'))

#    print(a / b)

# except ZeroDivisionError:

#    print('0不能作为除数')

# except ValueError:

#    print('不能是字符串')

#######################################################################################################

# try...except...else

# 如果try中的代码没有出现异常执行else中的代码，如果出现异常执行except中的代码

# try:

#    a = int(input('请输入一个整数'))

#    b = int(input('请输入一个整数'))

#    c = a / b

# except BaseException as e:

#    print(e)

# else:

#    print(c)

#######################################################################################################

# try...except...else...finally

# finally块中的代码，无论是否异常都会执行，通常用来释放try中申请的资源

# try:

#    a = int(input('请输入一个整数'))

#    b = int(input('请输入一个整数'))

#    c = a / b

# except BaseException as e:

#    print(e)

# else:

#    print(c)

# finally:

#    print('欢迎下次光临')

#######################################################################################################

# traceback模块的使用

# import  traceback

# try:

#    print(10/0)

# except:

#    traceback.print_exc()