Python学习

文章目录

• • 一、基础了解
  • 二、 运算符
  • 三、 函数
  • 四、 列表
  • 五、 字典
  • 六、元组
  • 七、集合
  • • 数据类型总结
  • 八、数据类型转换
  • 九、字符串
  • 十、流程控制
  • 十一、函数
  • 十二、异常处理
  • 十三、一些有趣的计算案例

一、基础了解

Python是解释型语言，不需要编译
Python是交互型语言
Python区分大小写

1. 变量

# 可以连续定义变量
a, b = 10, 20
# 直接进行变量的数据交换
a, b = b, a
print(a, b)

# 大字符串,可以换行(当三引号有变量来进行接收)
s='''hh
今天天气不错
'''
print(s, type(s))

# 单双引号可以互相嵌套，但是不能嵌套自己
s1 = 'i “love” you'
print(s1)   # i “love” you

# 转义字符，不想转义前面加r
z = 'hello nworld'
z1 = r'hello nworld'
print(z)
print(z1)  # hello nworld

2. Python输入内容到文件

# 数据输出到文件中，1、指定的盘符存在，2、使用file=xx形式
fp = open('D://test.txt', 'a+')  # a:如果文件不存在则创建，如果存在则在后面追加内容
print("hello", file=fp)
fp.close()

3. Python的原字符 r / R

# 原字符：不希望转义字符起作用，就使用原字符，在字符串前面加上r或R
# 注意：最后一个字符不能是反斜线
print(r'hellonworld')

4. python中的保留字

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

二、 运算符

1. 算术运算
   需要注意负数的除法和取模运算

print(11/2)  # 除法运算 5.5
print(11//2)  # 整除 5
# 负数的整除会向下取整
print(-9 // 4)  # -3

print(11 % 2)  # 取模运算 1
# 负数取余公式：余数=被除数-除数*商
print(9 % -4)  # 9-(-4)*(-3) --->  9-12 = -3
print(11**2)  # 幂运算 121

2. 字符运算

'''
    1. 字符串和数字不能直接参与运算
    2. 字符串和字符串使用 + 结果是字符串的拼接
    3. 字符串如果和数字使用 * 那么就是重复前面的字符串
'''
# print(1 + '2')
print('1'+'1')  # 11
print('1'*5)    # 11111

# 字符串拼接技巧
l = 'love'
# i = 'i '+l+' you'
# i = f'i {l} you'
# i = 'i {} you'.format(l)
i = 'i {l} you'.format(l=l)
print(i)  # i love you

3. 逻辑运算

# 逻辑运算与或非 and or not
a = True
b = True
c = False
d = False
print(a and b)  # True
print(a and c)  # False
print(40 and 30)  # 30
print(0 and 30)  # 0

print(a or b)  # True
print(c or d)  # False
print(20 or 10)  # 20

print(not True) # False
print(not False)  # True

4. 赋值、比较运算

# 支持系列解包赋值(变量与值的个数必须一致)
a, b, c = 10, 20, 30
print(a, b, c)
# 交换变量
a, b = b, a
print("a:"+str(a), "b:"+str(b))

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

# 布尔运算符
flag = True
print(not flag)  # False

s = 'helloworld'
print('o' in s)  # True
print('h' not in s)  # False

# 位运算
print(4 & 8)  # 0  按位与
print(4 | 8)  # 12 按位或
print(4 ^ 8)  # 12 按位异或
print(~8)  # -9 按位取反
print(4<<2)  # 左移一位相当于*2 4*2*2=16
print(4>>2)  # 右移一位相当于/2 4/2/2=1

# 进制转换
# bin() 转二进制
print(bin(125))  # 0b1111101
# int() 转十进制
print(int(0b1111101))  # 125

5. 其他运算符

# 检测成员是否存在 in   not in
print('love' in 'iloveyou')  # True
print('pao' not in 'iloveyou') # True

# 比较两个对象的存储单元 is    is not
a = 10
b = 10
print(id(a)) # 23818512
print(id(b)) # 23818512
print(a is b) # True
# is用于判断两个变量引用对象是否为同一个，==用于判断引用对象的值是否相等

三、 函数

1. if else的简写

# if else的简写
a = int(input('a'))
b = int(input('b'))
print(str(a)+'大于等于'+str(b) if a >= b else str(a)+'小于'+str(b))  # 符合执行左边，不符合执行else

2. 内置函数range

• 常用于for循环的遍历条件

'''
内置函数：前面不需要加任何前缀，直接可以使用的函数
内置函数range()
    用于生成了整数序列
    - range(stop)
    - range(start,stop)
    - range(start,stop,step)

range类型的优点：
    不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start、stop和step，
    只有当用到range对象时，才会去计算序列中的相关元素
'''
r = range(10)   # 默认从0开始，步长为1
print(r)  # range(0, 10)
print(list(r))   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  --- > list 是列表，可以查看range对象中的整数序列

r = range(1, 10)
print(list(r))  # [1, 2, 3, 4, 5, 6, 7, 8, 9] 从1开始，不包括10

r = range(1, 10, 2)
print(list(r))  # [1, 3, 5, 7, 9]

# 使用 in 或 not in 判断一个整数在序列中是否存在
print(10 in r)  # False
print(9 in r)   # True


for item in range(3):
    pwd = input("输入密码")
    if pwd == '8888':
        break
    else:
        print("密码不正确")


for i in range(1, 51):
    if i % 5 != 0:
        continue
    print(i)

3. else与循环体的使用

# else不仅可以搭配if使用，也可以用于while、for循环正常结束后的调用，只要没有遇到break
for i in range(3):
    pwd = input("输入密码")
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print("密码错误")
else:
    print('对不起，三次机会使用完毕')

四、 列表

# 列表用来表示一系列数据，它存储的类型可以是任意类型的
# 需要记录多个数据时，可以使用中括号进行定义[],每个数据使用逗号分隔
# 列表可以通过下标取值 （-length）0~length-1（-1）

1. 列表的查询

# 列表实际存储的是对象的引用
a = list("hello")
print(a)  # ['h', 'e', 'l', 'l', 'o']

# 列表的索引顺序：正从0开始，倒从-1开始
lst = ['hello', 'world', 'paopao', 'hello']
print(id(lst))  # 23192808
print(type(lst))  # 
print(lst)  # ['hello', 'world', 'paopao', 'hello']
print(lst[2])  # paopao
print(lst[-1])  # paopao


# 查找元素的索引,返回元素第一次查找到的索引，元素不存在则报错
print(lst.index('world'))  # 1
# print(lst.index("aa"))  报错，索引不存在
# print(lst.index('hello', 1, 3))  # 指定查找的始末位置，不包括3
print(lst.index('hello', 1, 4))  # 3

'''
根据索引获取元素
    正向：0 ~ N-1
    逆向：-N ~ -1
    索引不存在，抛出indexError
'''

2. 列表的添加

# 列表的增删改
lst = [10,20,30]
''' 1.列表后添加'''
lst.append(100)
print(lst)  # [10, 20, 30, 100]

lst2 = ['hello', 'world']
lst.append(lst2)  # 将列表2作为一个对象添加到lst末尾
print(lst)  # [10, 20, 30, 100, ['hello', 'world']]

lst3 = ['paopao', 'oo']
'''2.向列表的末尾一次性添加多个元素'''
lst.extend(lst3)
print(lst)  # [10, 20, 30, 100, ['hello', 'world'], 'paopao', 'oo']

'''3.任意位置添加元素'''
lst.insert(1, 90)
print(lst)  # [10, 90, 20, 30, 100, ['hello', 'world'], 'paopao', 'oo']

'''4.切片：在任意位置上添加n多个元素'''
lst4 = [False, True, 'nono']
# lst = lst[:3]+lst4+lst[3:]  这种方式可以在任意位置插入多个元素
lst[1:] = lst4
print(lst)  # [10, False, True, 'nono'] 实现了替换

3. 列表的删除

# 列表的移出
mylst = [10, 20, 30, 40, 50, 60, 30]
'''1.从列表中移出一个元素，如果有重复元素只移出第一个元素
    元素不存在则抛出ValueError
'''
mylst.remove(30)
print(mylst)  # [10, 20, 40, 50, 60, 30]
'''
    2. 删除一个指定索引位置上的元素，指定索引不存在则抛出IndexError
    不指定索引，则删除列表中最后一个元素
    pop() 这方法会返回被删除的元素
'''
mylst.pop(1)
print(mylst)  # [10, 40, 50, 60, 30]
# mylst.pop(5)  IndexError: pop index out of range
print(mylst.pop())  # 30 不指定索引，删除列表最后一个元素

'''
    3.切片：一次至少删除一个元素,将产生一个新的列表对象
'''
print(mylst)  # [10, 40, 50, 60]
new_mylst = mylst[1:3]
print("原列表", mylst)  # 原列表 [10, 40, 50, 60]
print("新列表", new_mylst)  # 新列表 [40, 50]

'''不产生新的对象，而是删除原列表中的内容
    使用空列表代替要删除的元素
'''
mylst[1:3] = []
print(mylst)  # [10, 60]

'''
    4. 清除列表中所有元素 clear()
    5. del语句将列表对象删除
'''
mylst.clear()
print(mylst)  # []
del mylst
# print(mylst)  # NameError: name 'mylst' is not defined

4. 列表元素的修改

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

5. 列表的排序

# 列表的排序操作
'''
    1.sort()原列表改变
    2.内置函数sorted()会产生新的列表对象
'''
lst5 = [20, 10, 30, 60, 50]
print("排序前", lst5)  # 排序前 [20, 10, 30, 60, 50]
lst5.sort()
print("排序后", lst5)  # 排序后 [10, 20, 30, 50, 60]  默认升序reverse=False
lst5.sort(reverse=True)  # 降序排列
print(lst5)  # [60, 50, 30, 20, 10]

# 使用内置函数sorted()
lst6 = [20, 10, 30, 60, 50]
new_list = sorted(lst6,reverse=True)
print(new_list)  # [60, 50, 30, 20, 10]

6. 列表表达式

# 列表生成式
'''
    for i in range(1, 10) 产生的值又赋给i
    
    最前面的i就是列表元素表达式，表示列表元素中所真正包含元素的值
'''
lst = [i for i in range(1, 10)]
print(lst)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
'''产生的i乘以本身'''
lst = [i*i for i in range(1, 10)]
print(lst)  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

五、 字典

• 字典：python的内置的数据结构之一，与列表一样是一个可变序列
  • 以键值对的方式存储数据，字典是一个无序的序列

1. 字典的创建

# 字典是键值对的存储方式  name:admin，使用 {} 定义  (类似java中的map?)
# 键和值之间使用冒号进行分隔，多组键值对之间使用逗号分隔
# 键必须是字符串或数字类型，值可以是任意类型，键名不能重复(后面会覆盖前面)，值可以重复

'''
    1. 字典的创建
        使用花括号 scores = {'张三':100}
        使用内置函数 dict(name='jack',age=20)
'''
score = {'张三': 100, '李四': 200, '万五': 300}
print(score)
score2 = dict(name='jack', age=10)
print(score2)
'''

2. 字典值的获取

'''
    2. 字典值的获取
        使用[]，获取不存在的元素会报错
        使用get(key)，获取不存在的元素返回None
'''
print(score2['name'])  # jack
print(score.get('张三'))  # 100
print(score.get('哈哈'))  # None
print(score.get('不存在', 99))  # 99,当值不存在时，显示默认值

3. 字典的增删改

'''
    3. 字典值的增删改
'''
# 判断存在
print('张三' in score)  # True
# 删除指定键值对
del score['张三']
print(score)  # {'李四': 200, '万五': 300}
# 清空字典
score.clear()
print(score)  # {}
# 新增元素
score['成六'] = 96
print(score)  # {'成六': 96}
# 修改值
score['成六'] = 100
print(score)  # {'成六': 100}

4. 字典的视图操作

'''
    字典的视图操作
    keys()  获取字典中所有的key
    values() 获取字段中所有value
    items()  获取字典中所有key,value对    
'''
score3 = {'张三': 100, '李四': 200, '万五': 300}
keys = score3.keys()
print(keys, type(keys))  # dict_keys(['张三', '李四', '万五']) 
print(list(keys))  # ['张三', '李四', '万五']  将所有keys组成的视图转换为列表
values = score3.values()
print(values, type(values))  # dict_values([100, 200, 300]) 
print(list(values))
items = score3.items()
print(items)  # dict_items([('张三', 100), ('李四', 200), ('万五', 300)])  
print(list(items))  # [('张三', 100), ('李四', 200), ('万五', 300)] 元祖()

5. 字典的常用操作

'''
    字典的常用操作：遍历
'''
for item in score3:
    print(item, score3[item])  # 张三 100 item为键
    print(score3.get(item))  # 获取值

6. 字典的特点

'''
字典的特点:
    1. 字典的key不允许重复,value可以重复
    2. 字典的元素是无序的
    3. 字典中的key必须是不可变对象
    4. 字典可以根据需要动态地伸缩
    5. 字典会浪费较大的内存，是一种使用空间转换时间的数据结构
'''
d = {'name': '张三', 'name': '老师'}
print(d)  # {'name': '老师'}

7. 字典生成式

'''
    内置函数zip()
        用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元祖，然后返回由这些元祖组成的列表
    
'''
scores4 = {}
items = ['Fruits', 'Books', 'Others']
prices = [96, 97, 98]
i = len(prices)-1
for item in items:
    scores4[item] = prices[i]
    i-=1
print(scores4)  # {'Fruits': 98, 'Books': 97, 'Others': 96}

print('------------- 字典生成式 -------------')
d = {item:price   for item, price in zip(items, prices)}
print(d)  # {'Fruits': 96, 'Books': 97, 'Others': 98}

六、元组

1. 元组的创建

# 元组与列表类似，用小括号进行定义，并且小括号可以省略
# 列表中的值是可以改变的，当元组里的值不允许被修改

'''
    元组：python内置数据结构之一，是一个不可变序列

    不可变序列：字符串、元组
        不可变序列：没有增删改操作
    可变序列：列表、字典
        可变序列：可以对序列进行增删改操作，对象的地址不发生更改
'''

'''
    元组的创建方式
'''
# 1.使用小括号
t = ('python', 'hello', 90)
print(t, type(t))  # ('python', 'hello', 90) 
t2 = 'python', 'hello', 90  # 小括号可以省略
print(t2, type(t2))
# 只包含一个元组的元素需要使用逗号和小括号，不加逗号会被识别为本身的数据类型
t4 = (10,)
print(t4, type(t4))  # (10,) 

# 2.使用内置函数tuple()
t3 = tuple(('python', 'hello', 90))

'''
    空列表：lst=[]  lst1=list()
    空字典：d={}   d2=dict()
'''
# 空元组
t4=()
t5=tuple()

2. 元组为不可变对象

'''
    元组中存储的是对象的引用
        1. 如果元组对象本身是不可变对象，则不能再引用其他对象
        2. 如果元组中的对象是可变对象，则可变对象的引用不允许修改，但数据可以改变
'''
t=(10, [20, 30], 40)
# t[1]=100  # 元组是不允许修改元素的
print(t[1], id(t[1]))  #  [20, 30] 27291528
print(t)  # (10, [20, 30], 40)
''' 由于[20, 30]是列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)
print(t)  # (10, [20, 30, 100], 40)
print(t[1], id(t[1]))  # [20, 30, 100] 27291528

3. 元组的遍历

# 元组的遍历
tt = ('python', 'hello', 90)
# 1. 使用索引，但是必须得指定有多个个元素，否则可能出现索引越界问题
print(tt[0], tt[1], tt[2])
# 2.遍历元组
for item in tt:
    print(item)

七、集合

1. 集合的创建

# set集合是一个 无序且元素不重复的 集合的数据类型
# set 集合使用 {} 或 set()方法来定义,定义空集合只能使用set(),因为大括号是定义空字典的

'''
    集合：
        python提供的内置数据结构
        与列表、字典一样都属于可变类型的序列
        集合是没有value的字典，需要和字典进行区分
'''
'''
1. 集合的创建
    使用{}
    使用内置函数set()
2. 集合中不允许有重复元素，并且集合是无序的
'''
j = {1, 2, 3, 2, 5, 6, 7, 5}
print(j)  # {1, 2, 3, 5, 6, 7} 不允许重复
j2 = set(range(6))
print(j2, type(j2))  # {0, 1, 2, 3, 4, 5} 
# 将列表转为集合
j3 = set([1, 2, 3, 5, 5, 6, 7])
print(j3, type(j3))  # {1, 2, 3, 5, 6, 7}  对列表实现去重
# 将元组转为集合
j4 = set((1, 2, 3, 5, 5, 65, 7))
print(j4, type(j4))  # {65, 1, 2, 3, 5, 7}   集合中的元素是无序的
# 集合
s1 = set('python')
print(s1, type(s1))  # {'t', 'h', 'y', 'n', 'p', 'o'} 
s2 = set({65, 1, 2, 3, 5, 7})
print(s2, type(s2))  # {65, 2, 3, 1, 5, 7} 

# 定义一个空集合
s3 = {}
print(s3, type(s3))  # {}  空字典
s4 = set()
print(s4, type(s4))  # set()   空集合

2. 集合的相关操作

'''
    集合的相关操作
    1. 检测元素是否存在 in / not in
    2. 元素的新增操作
        add() 一次添加一个元素
        update()  至少添加一个元素
    3. 元素的删除操作
        remove()    一次删除一个指定元素，如果元素不存在则耙齿KeyError
        discard()   一次删除一个指定元素，如果元素不存在不抛异常
        pop()       一次只删除一个任意元素
        clear()     清空集合
'''
print(65 in s2)   # True
print(65 not in s2)  # False

s = {10, 20, 30, 40, 50}
s.add(80)
print(s)  # {80, 50, 20, 40, 10, 30}
s.update({200, 400, 300})
print(s)  # {40, 200, 10, 300, 80, 400, 50, 20, 30}
# 可以放列表
s.update([88, 99, 77])
s.update((65, 66, 67))
print(s)  # {65, 66, 99, 67, 40, 200, 10, 300, 77, 80, 400, 50, 20, 88, 30}

# 删除元素
s.remove(40)
# s.remove(411)  抛异常
s.discard(411)  # 不抛异常
s.pop()
print(s)
s.clear()  # 清空集合
print(s)  # set()

3. 集合间的关系

'''
    集合间的关系
        1. 判断集合相等：集合是无序的，只根据元素内容判断而不是顺序
        2. 判断一个集合是否为另一个集合的子集:issubset
        3. 判断一个集合是否为另一个集合的超集:issuperset
        4. 判断两个集合是否没有交集 isdisjoint
        
'''
# 集合是否相等(元素相等就相等)
ss1 = {10, 20, 30, 40}
ss2 = {20, 40, 10, 30}
print(ss1 == ss2)  # True

# 一个集合是否为另一个集合的子集
ss3 = {10, 20, 30, 40, 50, 60}
ss5 = {10, 20, 30, 40}
ss6 = {10, 20, 90}
ss7 = {100, 200, 300}
print(ss5.issubset(ss3))  # True
print(ss6.issubset(ss3))  # False

# 一个集合是否为另一个集合的超集
print(ss3.issuperset(ss5))  # True
print(ss3.issuperset(ss6))  # False

# 两个集合是否没有交集
print(ss3.isdisjoint(ss5))  # False  有交集
print(ss3.isdisjoint(ss7))  # True  无交集

4. 集合的数学关系

# 交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30}

# 并集
print(s1.union(s2))  # {40, 10, 50, 20, 60, 30}
print(s1 | s2)  # {40, 10, 50, 20, 60, 30}

# 差集
print(s1.difference(s2))  # {10}
print(s1 - s2)  # {10}
print(s2.difference(s1))  # {50, 60}

# 对称差集
print(s1.symmetric_difference(s2))  # {50, 10, 60}

5. 集合生成式

''' 列表生成式 '''
lst = [i*i for i in range(6)]
print(lst)  # [0, 1, 4, 9, 16, 25]
''' 集合生成式 '''
s = {i*i for i in range(6)}
print(s)  # {0, 1, 4, 9, 16, 25}

数据类型总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表(list)	可变	可重复	有序	[]
元组(tuple)	不可变	可重复	有序	()
字典(dict)	可变	key不可重复，value可重复	无序	key:{value}
集合(set)	可变	不可重复	无序	{}

八、数据类型转换

• 自动转换

• 强制转换

  • str()
  • int()
  • float()
  • bool()
  • list()
  • tuple()
  • dict()
  • set()

• 容器类型的数据转换

  • 数字类型是 非容器类型,不能转换为列表/元组
  • 字符串 转换为列表时,会把字符串中的每一个字符当做列表/元组的元素
  • 集合 可以转换为 list列表/元组类型
  • 元组/列表 可以转换为 list列表/元组tuple类型
  • 字典 可以转换为 list列表/元组类型，只保留原来字典中的键

• 转换为字典

  • 列表/元组可以转换为字典，要求是一个二级列表/元组，并且每一个二级元素只能有两个值
  • 集合转字典，仅当集合中存储的是元组，并且元组的元素只能有两个值

n = [[1, 2], ['a', 'b']]   # n = [[1, 2], ['a', 'b']]
n = ((1, 2), (3, 4))  # {1: 2, 3: 4}
n = {(5, 6), (7, 8)}  # {5: 6, 7: 8}
res = dict(n)

九、字符串

• 字符串是python基本数据类型，是一个不可变的字符序列

1. 字符串驻留机制
   仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python驻留机制对相同的字符串值保留一份拷贝，后续创建新的字符串时，不会开辟新的空间，而是把该字符串的地址赋给新创建的变量

• 驻留机制的机制情况
  • 字符窗的长度为0和1时
  • 符合标识符的字符串
  • 字符串只在编译时进行驻留，而非运行时
  • [-5.256]之间的整数数字
  • 可以使用sys中的intern方法强制两个字符串指向同一个对象，不过在pyCharm中对字符串已经做了优化处理

2. 字符串的查询操作方法

• index() 查找字串substr第一次出现的位置，如果查找的子串不存在，则抛出ValueError
• rindex() 查找字串substr最后一次出现的位置，如果查找的子串不存在，则抛出ValueError
• find() 查找字串substr第一次出现的位置，如果查找的子串不存在，则返回-1
• rfind() 查找字串substr最后一次一次出现的位置，如果查找的子串不存在，则返回-1

3. 字符串大小写转换方法

• upper()
• lower()
• swapcase():大写转小写，小写转大写
• capitalize():第一个字符转为大写，其余字符转为小写
• title():把每个单词的第一个字符转为大写，每个单词剩余字符转为小写

4. 字符串的对齐操作

'''
    字符串的对齐操作
    center():居中对齐，可指定宽度和填充符
    ljust():左对齐
    rjust():右对齐
    zfill():右对齐，左侧用0填充 ,只接收一个参数
'''
s2 = 'hello,python'
print(s2.center(20, '*'))  # ****hello,python****
print(s2.ljust(20, '*'))  # hello,python********
print(s2.rjust(20, '*'))  # ********hello,python
print(s2.zfill(20))  # 00000000hello,python ：右对齐，左侧用0填充

5. 字符串的分割

• split()

'''
    字符串的分割
    1. split():不指定分隔符，则默认为空格分割
        参数sep指定字符串的分割符
        参数maxsplit指定最大分割数，分割之后剩下的子串将会作为单独的一部分
    2. rsplit():从字符串右侧开始分割，当指定了最大分割数时两种分割方法会有区别
'''
s3 = 'hello world python'
lst = s3.split()
print(lst)  # ['hello', 'world', 'python']
s4 = 'hello|world|python'
lst1 = s4.split('|')
print(lst1)
lst2 = s4.split(sep='|', maxsplit=1)
print(lst2)  # ['hello', 'world|python']

print(s3.rsplit())
print(s4.rsplit('|'))
print(s4.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'python']

6. 字符串的常用操作

• 字符串替换：
  replace:第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，第三个参数可以指定最大替换次数
• 字符串合并：
  join:将列表或元组中的字符串合并成一个字符串

'''
    字符串的常用操作
        isidentifier():判断是否为合法标识符(字符、数字、下划线)
        isspace():判断字符是否全部由空白字符组成(回车、换行、水平制表符)
        isalpha():判断字符串是否全部由字母组成
        isdecimal:判断字符串是否全部由十进制数字组成
        isnumeric:判断字符串是否全部由数字组成
        isalnum():判断字符串是否全部由字母数字组成      
'''

s5 = 'hello,python'
print('1.', s5.isidentifier())  # 1. False
print('2.', '_hello'.isidentifier())  # 2. True
print('3.', 't'.isspace())  # 3. True
print('4.', 'abc'.isalpha())  # 4. True
print('5.', '12345'.isdecimal())  # 5. True
print('6.', '123四'.isnumeric())  # 6. True
print('7.', '123abc'.isalnum())  # 7. True


print('-------------------------------------')

'''
 字符串替换：
        replace:第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，第三个参数可以指定最大替换次数
 字符串合并：
        join:将列表或元组中的字符串合并成一个字符串
'''
s6 = 'hello,python'
print(s6.replace('python', 'java'))  # hello,java

s6 = 'hello,python,python,python'
print(s6.replace('python', 'java', 2))  # hello,java,java,python

lst = ['hello', 'java', 'python']
print('|'.join(lst))  # hello|java|python
print(''.join(lst))  # hellojavapython

t = ('hello', 'java', 'python')
print('*'.join(t))  # hello*java*python

print('$'.join('Python'))  # P$y$t$h$o$n  将字符串作为字符串序列进行拼接

7. 字符串的比较操作

'''
    字符串的比较操作
        运算符：> 、>= 、< 、<= 、 == 、!=
    比较规则：对字符依次进行比较，相同则继续，不同则结束
    比较原理：字符比较其实是比较其原始值，可以使用内置函数ord()计算原始值，而与ord()相对的内置函数是chr()
    
    == 比较的是value
    is 比较的是id是否相等
'''

print('apple' > 'app')  # True
print('apple' > 'banana')  # False
print(ord('a'), ord('b'))  # 97 98
print(chr(97))  # a

7. 字符串的切片操作

'''
    字符串的切片操作
        字符串是不可变类型：不具备增删改操作，切片操作将产生新的对象
'''
str = 'hello,Python'
str1 = str[:5]  # 不指定开始，则从0开始，直到索引5，不包括5
print(str1)  # hello
str2 = str[6:]  # 索引6开始到结束
print(str2)  # python
s3 = '!'
new_str = str1 + s3 + str2
print(new_str)  # hello!Python

'''  切片[start:end:step]  '''
print(str[1:5:1])  # ello
print(str[::2])  # 默认从0开始，不指定结束位置则默认到字符串的最后一个元素，步长（元素间隔）为2
print(str[::-1])  # 倒序：nohtyP,olleh  从右侧开始，步长为-1 
print(str[-6::1])  # Python  -6 -5 -4 -3 -2 -1 从索引为-6开始，到最后一个元素结束，步长为1

8. 格式化字符串

'''
    格式化字符串
    1. % 作为占位置
        %s: 字符串
        %i，$d: 整数
        $f: 浮点数
    2. {} 作为占位符
        {0}数字为索引
    3. f-string:格式化字符串
'''
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age))  # 我叫张三,今年20岁
print('我叫{0},今年{1}岁,我叫{0}'.format(name, age))  # 我叫张三,今年20岁,我叫张三
print(f'我叫{name},今年{age}岁')  # 我叫张三,今年20岁

print('--------------------------------------')
# 宽度和精度设置
print('%10d' %  99)  # 宽度为10          99
print('%f' %  3.1415926)  # 3.141593
print('%.3f' %  3.1415926)  # 3.142 保留精度 .3表示小数点后3位
# 同时表示宽度和精度
print('%10.3f' %  3.1415926)  #      3.142

print('{0}'.format(3.1415926))  # 3.1415926  {0}代表占位符顺序
print('{0:.3}'.format(3.1415926))  # 3.14   .3表示一共3位
print('{0:.3f}'.format(3.1415926))  # 3.142    .3f表示3位小数

print('{0:10.3f}'.format(3.1415926))  #      3.142 同时设置宽度和精度

9. 字符串的编码转换

'''
    字符串的编码转换
        编码encode：将字符串转为二进制数据（bytes）
        解码decode：将bytes类型的数据转为字符串类型
'''
str = '天涯共此时'
# 编码
print(str.encode(encoding='GBK'))  # GBK 一个中文占两个字节
print(str.encode(encoding='UTF-8'))  # UTF-8 一个中文占三个字节
# 解码
byte = str.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))  # 天涯共此时
# print(byte.decode(encoding='UTF-8'))  UnicodeDecodeError: 'utf-8' codec can't decode byte 0xcc 编码格式和解码格式要相同
byte2 = str.encode(encoding='UTF-8')
print(byte2.decode(encoding='UTF-8'))  # 天涯共此时

---

十、流程控制

• 流程就是计算机执行的顺序，顺序结构、分支结构、循环结构

十一、函数

1. 函数的创建

• 在函数调用过程中，进行参数的传递
  如果是不可变对象，在函数体的修改不会影响实参的值
  如果是可变对象，在函数体内的修改会影响实参的值

'''
    函数的创建
	    def 函数名(参数):
	        函数名
	        return xxx
'''
def chan(a, b):   # a,b为形参
    print("a", a)  # 15
    print("b", b)  # b [1, 2, 3, 4]
    a = 10
    b.append(10) 

# print(add(1, 2))  # 实参
# print(add(b=30, a=20))  # 按关键字进行参数传递
a = 15
b = [1,2,3,4]
chan(a,b)
print(a)  # 15
print(b)  # [1, 2, 3, 4, 10]

2. 函数的返回值

'''
    函数的返回值
        函返回一个值，函数返回类型
        函数返回多个值时，结果为元组】
        函数可以没有返回值，省略return
'''

def fun(num):
    odd = []
    even = []
    for i in num:
        if i%2 == 1:
            odd.append(i)
        else:
            even.append(i)
    return odd,even


print(fun([1,2,3,4,5,6,7]))   # print(fun([1,2,3,4,5,6,7]))

3. 函数的参数

'''
    1. 两者都不可以重复填写：(*args,*args) (**args,**args) 
        个数可变的位置参数
            未知传参个数时使用，*定义，结果为一个元组
        个数可变的关键字形参
            未知传递的关键字实参个数时使用，**定义，结果为一个字典
    当两者同时存在时定义：(*args,**args) 
'''
def fun1(*args):
    print(args)

fun1(10, 20, 30, 40)  # (10, 20, 30, 40)


def fun2(**args):
    print(args)

fun2(a=10,b=20,c=30)  # {'a': 10, 'b': 20, 'c': 30}

def fun3(a, b, c):
    print("a", a)
    print("b", b)
    print("c", c)

lst = [1,2,3]
dict = {'a':111, 'b':222, 'c':333}
fun3(*lst)  # 函数调用时，将列表中的每个元素都转为未知实参传递
fun3(**dict)  # 关键字传参，将字典中的键值对都转换为关键字实参

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

# fun4(1,2,3,4) 函数保存，传参错误
fun4(1,2,c=3,d=4)

4. 函数的作用域

'''
    变量的作用域
        局部变量：在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就后悔成为全局变量
        全局变量：函数体外定义的变量，可作用于函数内外
'''
def fun5():
    global name
    name = '张三'
    age = 20
    print(age)

fun5()  # 20
# print(age)  报错
print(name)  # 张三

5. 递归函数

'''
    递归函数：自己调用自己
        找出口
'''
# 计算阶乘
sum = 1
def digui(num):
    if num==1:
        return 1
    else:
        return num*digui(num-1)

print(digui(6))  # 720

# 斐波那契数列
def fei(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fei(n-1)+fei(n-2)

print(fei(6))  # 8

十二、异常处理

1. 常见的bug
   遗漏末尾的冒号
   缩进错误
   input获取非字符类型没有转换
   “==”与“=”的混用
2. 常见异常

序号	异常类型	描述
1	ZeroDivsionError	除（取模）0（所有数据类型）
2	IndexError	序列中没有此索引（index）
3	KeyError	映射中没有这个键
4	NameError	未声明/初始化对象（没有属性）
5	SyntaxError	Python语法错误
6	ValueError	传入无效的参数

3. 异常处理

• try…except

'''
    异常处理机制：
        try:
        except xxx:
    多个except结构：捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加baseException
'''
try:
    n1 = int(input("请输入整数"))
    n2 = int(input("请输入整数"))
    res = n1/n2
    print('结果为：', res)
except ZeroDivisionError:
    print('除数不能为0')
except ValueError:
    print('只能输入数字')
print('程序结束')

• try…except…else

'''
    try...except...else结构
        如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块
'''

try:
    n1 = int(input("请输入整数"))
    n2 = int(input("请输入整数"))
    res = n1/n2
except baseException as e:
    print('出错了',e)
else:
    print('结算结果为：',res)

• try…except…else…finally

'''
    try...except...else...finally 结构
        finally块无论是否发生异常都会执行，通常用来释放try块中申请的资源
'''
try:
    n1 = int(input("请输入整数"))
    n2 = int(input("请输入整数"))
    res = n1/n2
except baseException as e:
    print('出错了',e)
else:
    print('结算结果为：',res)
finally:
    print('谢谢使用！')  # 是否出错都执行

4. traceback模块

'''
    traceback模块
        使用traceback模块打印异常信息
'''

import traceback
try:
    print('-----------')
    print(1/0)
except:
    traceback.print_exc()

十三、一些有趣的计算案例

# ☆★
print("============= 打印星星 =============")
num=0
flag=1
# 隔列打印
while num < 100:
    # 也可以通过对num%2
    if flag:
        print("☆", end="")
        flag=0
    else:
        print("★", end="")
        flag = 1
    if num % 10 == 9:
        print()
    num+=1


print("============= 打印星星 =============")
# 隔行打印
flag=True
num1=0
while num1 < 100:
    # num1//10%2
    if flag:
        print("☆", end="")
    else:
        print("★", end="")
    if num1 % 10 == 9:
        print()
        flag = not flag
    num1 += 1

'''
    for i in range(1,x):
'''
a=1
while a<10:
    b=1
    while b<=a:
        # print(str(b)+"*"+str(a)+"="+str(a*b), "t", end="")
        print(f"{b}*{a}={a*b}", end=" ")
        b+=1
    print()
    a+=1


print("---------------------")

# 反向输出
# i 1 2 3 4 5 6 7 8 9
for i in range(1,10):
    for z in range(1,11-i):
        print(f"{10-i}*{z}={z*(10-i)}", end=" ")
    print()

'''
    range 函数倒置-1指定 
        for i in range(x,0,-1)
'''
print("---------------------")
for y in range(9,0,-1):
    for q in range(1,y+1):
        print(f"{q}*{y}={q*y}",end=" ")
    print()


'''
斐波那契数列
    0,1,1,2,3,5,8,13 。。。 
第一个数为0，第一项为1，第二项也为1
第三项开始为前面两数之和
'''
f=1
b=1
tup = []
input1 = int(input("输入一个数"))
if input1 < 0:
    print("请输入一个正整数")
else:
    if input1==0:
        tup=[0]
    elif input1==1:
        tup=[0,1]
    else:
        tup = [0, 1]
        while b < input1:
            tmp = b
            b = f+b
            f = tmp
            tup.append(b)
        print(tup)

'''
一百块钱买一百只鸡
x公鸡=3
y母鸡=1
j小鸡=0.5
问: 100块钱买100只鸡，一共多少方案

1. 单独的母鸡
2. 单独的小鸡
3. 三种一起
'''
print("单独买母鸡",100)
# print("单独买小鸡",int(100/0.5)) 超过100只
count=0
# x,y,z同时都存在至少1只，
# for z in range(1,100+1):
#     for y in range(1,100+1):
#         for x in range(1,100//3+1):
# 这样三层循环的运算次数多，可以进行优化，当确定了公鸡和母鸡的个数时，就知道小鸡的个数了
# 解方程是无法解的，但是这里用的是穷举，因此可以确定两个数
for x in range(1, 100 // 3 + 1):
    for y in range(1, 100 + 1):
        # for z in range(1,100+1):
        z=100-x-y
        if (3*x+y+0.5*z==100 and x+y+z==100):
            print(f"公鸡：{x},母鸡：{y},小鸡：{z}")
            count+=1
print(f"一共有种{count+1}方案")