锐客网

  1. 首页 > it技术 > >

学习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)
#######################################################################################################
# innot 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
【学习python】#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就是falsefalse就进入判断中
#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 中的 elsewhile中的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模块的使用
# importtraceback
# try:
#print(10/0)
# except:
#traceback.print_exc()

    推荐阅读


    上一篇：诡异的梦

    下一篇：半夜醒了怎么办（）