文章目录

Python详细入门教程

第一章:

1.常见输出:

# Author : zxy
# Date : 2022/5/2 11:50
# 1.输出数字
print(520)
# 2.输出字符串1
print('hello world')
# 2.输出字符串2
print("hello world")
# 3.输出结果到文件
# 不存在即创建 存在即追加
fp = open('F:/text.txt','a+')
print('hello world',file=fp)
fp.close()
# 4.不换行输出
print('hello','world','python')

2.转义字符

# Author : zxy
# Date : 2022/5/2 12:12

# 转义字符-换行
print('hello\nworld')

# 转义字符-table键
print('hello\tpython')

# 转义字符-backspace
print('hello\bzxy')

# 转移字符-return
print('hello\rworld')

# 转义字符-\" \'
print("\"hello\"","\'world\'")

# 转义字符-\\
print("http:\\\\www.baidu.com")

# 原字符-不希望字符串中的转义字符起作用,就使用原字符,就是在字符串前加上r或者R
print(r"http:\\www.baidu.com")
# 原字符使用-末尾不能使用一个反斜杠结尾会报错,需要的话,使用两个
# print(r"http:\\www.baidu.com\")
print(r"http:\\www.baidu.com","\b\\")

第二章:

1.注释

# coding:utf-8
# Author : zxy
# Date : 2022/5/2 19:09

# Python代码中的注释
# 注释:
#   提高代码可读性
#   注释内容会被Python解释器忽略
#   三种注释类型:
#       单行注释:以#开头
"""
多行注释:将一对三引号之间代码称为多行注释
"""
#       中文编码声明注释:文件开头加上中文声明注释,用以指定源码文件的编码格式

2.标识符

# Author : zxy
# Date : 2022/5/2 15:07

import keyword

# 查看所有保留字
print(keyword.kwlist)

# 标识符规则
# 变量、函数、类、模块和其他对象起的名字就叫标识符
# 规则:
#   1.字母、数字、下划线
#   2.不能以数字开头
#   3.不能是保留字
#   4.严格区分大小写

3.变量

# Author : zxy
# Date : 2022/5/2 15:13

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

# 再次赋值后,会开辟新的内存空间
name = 'python'
print(name)

4.数据类型

# Author : zxy
# Date : 2022/5/2 18:22
from decimal import Decimal
# 数据类型
# 1.整数类型 int
#   1.1 可以表示正数、负数、0
n1 = 100
n2 = -100
n3 = 0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#   1.2 整数可以表示 为二进制 十进制 八进制 十六进制
#   1.2.1 二进制取值[0,1],逢2进一
print('二进制',0b10101111)
#   1.2.2 十进制取值[0,1,2,3,4,5,6,7,8,9] 逢10进一
print('十进制',118)
#   1.2.3 八进制取值[0,1,2,3,4,5,6,7] 逢8进一
print('八进制',0o176)
#   1.2.4 十六进制取值[0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] 逢16进一
print('十六进制',0x1EAF)
# 2.浮点数类型 float
f1 = 1.1
f2 = 2.2
#   输出结果3.3000000000000003,因为是通过二进制计算,存在浮点数小数点不准确性
print(f1,type(f1))
print(f1 + f2)
print(Decimal('1.1') + Decimal('2.2'))
# 3.布尔类型 bool
#   3.1 布尔判断
b1 = False
b2 = True
print(b1,type(b1))
if(b1) :
  print('true')
else :
  print('false')
#   3.2布尔相加
print(b1 + 1) # b1为false相当于0
print(b2 + 0) # b2为true相当于1
# 4.字符串类型 str
#   4.1 单引号,必须在一行
print('hello world',type('hello world'))
#   4.2 双引号,必须在一行
print("hello world",type("hello world"))
#   4.3 三引号,可以不在一行
print("""
        hello 
        world
        python
    """)
# 4.不同数据类型连接,使用str将int类型转成string类型
print('------------------------str()转换类型--------------------------')
name = '张三'
age = 28
print('我是'+name+',我今年'+str(age)+'岁了')
print('------------------------int()转换类型--------------------------')
s1 = '128'
s2 = True
s3 = 98.8
s4 = '98.8'
s5 = 'hello'
print(s1,type(s1),int(s1),type(int(s1)))
print(s2,type(s2),int(s2),type(int(s2)))
# float转成int,会将小数截取掉
# 将s4转成Int类型会报错,因为字符串为小数串
# 将s5转成int类型也会报错,因为字符串转成整数,该字符串必须为整数数字串
print(s3,type(s3),int(s3),type(int(s3)))

print('------------------------float()转换类型--------------------------')
s1 = '98.8'
s2 = '98'
s3 = True
s4 = 98
s5 = 'hello'
# 将s5转成float类型会失败,只允许为数字串(整数,浮点数)
print(s1,type(s1),float(s1),type(float(s1)))
print(s2,type(s2),float(s2),type(float(s2)))
print(s3,type(s3),float(s3),type(float(s3)))
print(s4,type(s4),float(s4),type(float(s4)))

5.字符编码

# Author : zxy
# Date : 2022/5/2 14:26

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

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

第三章

1.基础运算符

# Author : zxy
# Date : 2022/5/2 19:51

# 算术运算符 -> 位运算符 -> 比较运算符 -> 布尔运算符 -> 赋值运算符
# ** -> [*,/,//,%] -> [<<,>>] -> [&] -> [|] -> [>,<,<=,>=,==,!=] -> and -> or -> =

# 基础运算符
print(1+1) # 加法运算
print(1-1) # 减法运算
print(1*2) # 乘法运算
print(1/2) # 除法运算
print(11//2) # 整除运算符
print(11%2) # 取余运算符
print(2**2) # 2的2次方


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

2.比较运算符

# Author : zxy
# Date : 2022/5/2 20:25
# 比较运算符
a,b = 10,20
print('a>b?',a>b)
print('a<b?',a<b)
print('a>=b?',a>=b)
print('a<=b?',a<=b)
print('a==b?',a==b)
print('a!=b?',a!=b)
"""
    赋值运算符 =
    比较运算符 ==
    一个变量由三个部分组成,标识,类型,值
    == 比较的是值
    is 比较的是标识
"""
print('----------整数对比----------')
a = 10
b = 10
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)
print('---------数组对比,值相同,id标识不同-----------')
a = [1,2,3,4]
b = [1,2,3,4]
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)


3.赋值运算符

# Author : zxy
# Date : 2022/5/2 20:10

# 赋值运算符
# 执行顺序 : 从右至左
a = 1 + 2
print('从右至左,先执行加法再赋值',a)
# 支持链式赋值,执行同一空间 :a = b = c = 10
a = b = c = 10
print(a,id(a))
print(b,id(b))
print(c,id(c))
# 支持参数赋值 :+= =+ *= /= //= %=
a = 20
a += 30
print('-------------a+=30 类似于 a = a + 30------------------')
print(a)
# 支持系列解包赋值 : a,b,c = 20,30,40
print('-------------解包赋值------------')
a,b = 20,30
print(a,id(a))
print(b,id(b))
print('----------交换----------------')
a,b = b,a
print(a,id(a))
print(b,id(b))

4.布尔运算符

# Author : zxy
# Date : 2022/5/2 21:12

# 布尔运算符 and or not in not in
a,b = 10,20
# and 全真为真 一假为假
print(a==10 and b == 10)
# or 全假为假 一真为真
print(a==10 or b==10)
# not 取反
b1 = True
print(not b1)
# in
s1 = 'helloworld'
print('w' in s1)
print('z' in s1)
# not in
s1 = 'helloworld'
print('w' not in s1)
print('z' not in s1)

5.位运算符

# Author : zxy
# Date : 2022/5/2 21:44
# 位运算符 & | << >>

# 与运算符 & 同1为1 否则为0
# 0100
# 1000
# &
# 0000
print(4&8)

# 或运算符 | 同0为0 否则为1
# 0100
# 1000
# |
# 1100
print(4|8)

# 逻辑右移 >>
# 0100 => 4
# >> 1
# 0010 => 2
print(4>>1)

# 逻辑左移
# 0100 => 4
# << 1
# 1000 => 8
print(4<<1)

6.输入函数

# Author : zxy
# Date : 2022/5/2 19:42

# input输入函数
name = input('请输入你的名字:')
print(name,type(name))
# 转成int类型方式一
age = input('请输入你的年龄:')
print(age,type(age),int(age),type(int(age)))
# 转成int类型方式二
age = int(input('请输入你的年龄:'))
print(age,type(age))

第四章

1.顺序结构

# Author : zxy
# Date : 2022/5/2 22:21

# 顺序结构,把大象装冰箱
print('---------------程序开始--------------')
print('---------------1.打开冰箱--------------')
print('---------------2.大象放冰箱--------------')
print('---------------3.关冰箱门--------------')
print('---------------程序结束--------------')

2.选择结构-单分支

# Author : zxy
# Date : 2022/5/2 22:21

# 1.选择结构-单分支结构  银行取款

money = 1000

s = int(input('请输入取款金额:'))

if(money >= s):
    money -= s
    print('取款成功,剩余金额为:',money)

3.选择结构-双分支

# Author : zxy
# Date : 2022/5/3 10:31
# 2.选择结构-双分支结构 奇偶判断

i = int(input('请输入一个数字:'))

if i % 2 == 0:
    print('你输入一个偶数!')
else:
    print('你输入一个奇数!')

4.选择结构-多分支

# Author : zxy
# Date : 2022/5/3 10:31

# 3.选择结构-多分支结构 成绩等级划分

score = int(input('请输入一个成绩:'))

# if score >= 90 and score <= 100:
if 90 <= score <=  100:
    print('A级')
elif score >= 80 and score < 90:
    print('B级')
elif score >= 70 and score < 80:
    print('C级')
elif score >= 60 and score < 70:
    print('D级')
else:
    print('不及格')

5.选择结构-嵌套循环

# Author : zxy
# Date : 2022/5/3 10:31
# 4.选择结构-嵌套结构 商场购物
money = int(input('请输入你需要支付金额!'))
vip = bool(input('请输入你是否是会员?True/False'))
if vip:
    if money >= 200:
        print('你需要支付:',money * 0.8)
    elif money >= 100:
        print('你需要支付:',money * 0.9)
    else:
        print('你需要支付:',money)
else:
    if money >= 200:
        print('你需要支付:',money * 0.95)
    else:
        print('你需要支付:',money)

6.循环结构

# Author : zxy
# Date : 2022/5/2 22:21

"""
    循环结构
    while
    for - in
"""
def test1():
    a = 1
    while a < 10:
        print(a)
        a += 1
# 计算0到10的累加
def sum():
    '''初始化变量'''
    sum = 0
    a = 0
    '''条件判断'''
    while a <= 10:
        '''条件执行体'''
        sum += a
        a += 1
    print(sum)
# 1到100偶数和
def number():
    sum = 0
    i = 0
    while i <= 100:
        if i % 2 == 0:
            sum += i
        i+=1
    print('while计算求和',sum)
def number2():
    sum = 0
    for item in range(1,101):
        if item % 2 == 0:
            sum += item
    print('for-in计算求和:',sum)

# 100 到 1000 的水仙花
def water():
    for item in range(100,1001):
        ge = item % 10
        shi = item // 10 % 10
        bai = item // 100
        if ge**3+shi**3+bai**3 == item:
            print(item)

if __name__ == '__main__':
    number()
    number2()
    water()
    '''for-in'''
    for item in 'python':
        print(item)
    for i in range(10):
        print(i)
    for _ in range(1,3):
        print('hello python')

7.break语句

# Author : zxy
# Date : 2022/5/3 13:30
# 通过break退出循环
'''密码三次输入不成功退出,密码正确退出'''
for item in range(3):
    pwd = input('请输入密码:')
    if pwd == '8888':
        print('密码正确')
        break
    else :
        print('密码不正确')
else:
    print('三次密码均失败!')

8.continue语句

# Author : zxy
# Date : 2022/5/3 13:34

'''break是退出循环'''
'''continue是退出当前循环,继续下一个循环'''

'''1到50之间,5的倍数'''
for item in range(1,51):
    '''如果item不是5的倍数,就跳出当前循环,继续下一个循环'''
    if item % 5 != 0:
        continue
    print(item)

9.pass语句

# Author : zxy
# Date : 2022/5/3 10:44
# pass语句,什么都不做,只是一个占位符,用到需要写语句的地方
money = int(input('请输入你需要支付金额!'))
if money >= 200:
    pass
    # 当没想好怎么写的时候,可以先使用pass占位,继续写后面的操作
    # print('你需要支付:', money * 0.8)
elif money >= 100:
    print('你需要支付:', money * 0.9)
else:
    print('你需要支付:', money)

10.range函数

# Author : zxy
# Date : 2022/5/3 10:50

# range函数
'''一个参数,表示从0到10'''
n1 = range(10)
print(list(n1))

'''两个参数,从1开始到19'''
n2 = range(1,19)
print(list(n2))

'''三个参数,从1开始到19,步长为2'''
n3 = range(1,19,2)
print(list(n3))

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

11.对象的布尔值

# Author : zxy
# Date : 2022/5/2 22:36
"""
Python所有对象都有一个布尔值
   获取对象的布尔值,使用内置函数bool()
   以下对象的布尔值为False
       False
       数值0
       None
       空字符串
       空列表
       空元组
       空字典
       空集合
"""
print(bool(False)) #  False
print(bool(0.0)) # 数值0
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())) # 空集合

第五章

1.集合

# Author : zxy
# Date : 2022/5/3 22:41

# 集合
"""
集合:
    Python语言提供的内置数据结构
    与列表、字典一样都属于可变类型的序列
    集合是没有value的字典
"""

# 1.集合的创建
"""
集合的创建方式:
    直接{}
        s = {'python','java'}
    使用内置函数set()
        s = set(range(6))
        s = set([1,2,3,4])
        s = set((1,2,3,4))
        s = set('python')
        s = set({1,2,3,4})
        s = set()
"""

def create_tuple():
    s = {'python', 'java','java'} # 集合中元素不能重复,会把重复的元素自动去掉
    print(s,type(s))
    s = set(range(6))
    print(s, type(s))
    s = set([5, 2, 3, 4]) # 集合中元素是无序的
    print(s, type(s))
    s = set((1, 6, 3, 4))
    print(s, type(s))
    s = set('python')
    print(s, type(s))
    s = set({1, 2, -1, 4})
    print(s, type(s))
    s = set() # 空集合
    print(s, type(s))
    s = {} # 空字典
    print(s, type(s)) # 不能使用空的大括号创建集合,因为这默认是字典

# 2. 集合相关操作
"""
集合元素的判断
    in 
    not in 
集合元素的新增:
    add() ,一次添加一个元素
    update()至少添加一个元素
集合元素的删除:
    remove() ,一次删除一个指定元素,如果指定元素不存在抛出异常KeyError
    discord(),一次删除指定元素,如果指定元素不存在不抛出异常
    调用pop(),一次只删除一个任意元素
    调用clear() ,情况集合
"""
def opter_set():
    s = {'hello','my','python','time'}
    print('python是否在集合中?','python' in s)
    print('python是否不在集合中?', 'python' not in s)

    s.add('java')
    print('add添加元素Java:',s)

    s.update('a','b','c')
    print('update添加元素a,b,c:',s)

    s.remove('java')
    print('指定删除Java元素:',s)
    # s.remove('zxy') remove删除一个不存在的元素,会抛出异常
    s.discard('zxy')
    print('discard删除不存在的元素,不会报错:',s)
    s.pop()
    print('pop删除任意一个元素:',s)
    s.clear()
    print('clear清空所有集合元素:',s)

# 3.集合的关系
"""
两个集合是否相等
    可以使用运算符==或!=判断
一个集合是否是另一个集合的子集
    可以调用方法issubset进行判断
    B是A的子集
一个集合是否另一个集合的超集
    可以调用方法issuperset进行判断
    A是B的超集
两个集合是否没有交集
    可以调用方法isdisjoint进行判断
"""
def relation_set():
    s1 = {10,20,30,40}
    s2 = {40,10,20,30}
    s3 = {10,20}
    s4 = {60,70}
    print('s1和s2相同?',s1==s2)
    print('s1和s2不相同',s1!=s2)
    print('s3是s1的子集?',s3.issubset(s1))
    print('s1是s3的超集',s1.issuperset(s3))
    print('s1和s4没有交集?',s1.isdisjoint(s4)) # 没有交集为True,有交集为False

# 4.集合的数据操作
"""
    交集
    并集
    差级
"""
def data_opetate():
    s1 = {10, 20, 'hello'}
    s2 = {40, 10, 20, 30}
    print('方式一:s1和s2交集:',s1.intersection(s2))  # 交集
    print('方式二:s1和s2交集:',s1 & s2)
    print('方式一:s1和s2并集:',s1.union(s2))  # 并集
    print('方式二:s1和s2并集:',s1 | s2)
    print('方式一:s1减去[s1和s2的交集]:',s1.difference(s2))  # 差集
    print('方式一:s2减去[s1和s2的交集]:',s2.difference(s1))
    print('方式二:s1减去[s1和s2的交集]:', s1 - s2)
    print('方式二:s2减去[s1和s2的交集]:', s2 - s1)
    print('s1和s2的并集减去s1和s2的交集:',s1.symmetric_difference(s2)) # 对称差集
# 5. 集合生成式
def create_set():
    s = { i for i in range(6)}
    print(s,type(s))
if __name__ == '__main__':
    create_set()

2.列表

# Author : zxy
# Date : 2022/5/3 14:04

"""
列表:
    变量 可以存储一个元素,
        而列表是一个”大容器“可以存储N多个元素,
        程序可以方便的对这些数据进行整体操作
    列表相当于其他语言中的数组
特点:
    列表元素按顺序有序排序
    索引映射唯一一个数据
    列表可以存储重复数据
    任意数据类型混存
    根据需要动态分配和回收内存
"""
def test():
    lst = [98,98.8,'hello']
    print(lst,id(lst))
    print(lst,type(lst))
    print(lst)
    lst2 = list(lst)
    print(lst2,type(lst2))

    print(lst[0])
    print(lst2[0])

'''
元素位置索引
索引:
    正向 0 到 N
    逆向 -N 到 -1
'''
def index_test():
    lst = [98, 98.8, 'hello']
    print(lst.index(98))
    print(lst.index('hello',1,3))
"""
切片:
    获取列表中多个元素
切片的结果->原列表片段的拷贝
切片的范围->
"""
def split_test():
    lst = [10,20,30,40,50,60,70]
    print('原列表:',lst)
    print('起始位2,结束为6,步长为1:',lst[2:6:1])
    print('不设起始,结束为6,步长为2:',lst[:6:2])
    print('起始为2,不设结束,步长为1:',lst[2::1])
    print('不设起始,不设结束,步长为1',lst[::1])
    print('不设起始,不设结束,步长为-1,类似反转',lst[::-1])
"""
判断元素在列表中是否存在:
in 
not in
"""
def exists_test():
    lst = ['yyds','python','java']
    print('yyds' in lst)
    print('zxy' not in lst)
"""
    列表元素的遍历
"""
def list_test():
    lst = ['yyds', 'python', 'java']
    for ls in lst:
        print(ls)
"""
列表元素的增加操作
"""
def append_test():
    lst = ['yyds', 'python', 'java']
    lst2 = ['a','b','c']
    lst3 = [1,2,3]
    print('原数据',lst)
    lst.append('zxy')
    print('append追加后:',lst)
    lst.extend(lst2)
    print('extend追加多个元素:',lst)
    lst.insert(0,666)
    print('insert在索引为0的位置添加666:',lst)
    lst[1:]=lst3
    print('切片替换,从下标1开始的所有元素替换为lst3',lst)

def remove_test():
    lst = ['yyds', 'python', 'java','scala','html']
    print('原数据:',lst)
    lst.remove("yyds") # 从列表中移除一个元素,如果有重复元素,只移除第一个元素
    print('删除lst中指定元素',lst)
    lst.pop(0) # 通过指定索引,删除元素,如果不指定索引,则删除最后一个元素
    print('删除索引为0的数据:',lst)
    new_list = lst[1:3]
    print('切片删除,只留下索引1到3的数据,会产生新的列表对象:',new_list)
    lst[0:1] = []
    print('将列表中索引0到1的位置置空,相当于删除:',lst)
"""
修改列表元素
"""
def modify_test():
    lst = ['yyds', 'python', 'java', 'scala', 'html']
    print('原数据:', lst)
    lst[0] = 'bigdata'
    print('指定下标修改:',lst)
    lst[2:4] = [100,200,300,400]
    print('切片修改:',lst)
"""
排序查询
"""
def sort_test():
    lst = [40,10,30,90,100]
    print('原数据:',lst)
    lst.sort()
    print('不指定排序方式,默认升序排序:',lst)
    lst.sort(reverse=False)
    print('指定升序排序:', lst)
    lst.sort(reverse=True)
    print('指定降序排序:',lst)
    print('-------------------sorted()跟sort()的区别是,sort()是在原有list基础上排序,sorted()是生成新的列表-------------')
    lst = [40, 10, 30, 90, 100]
    print('原数据:', lst)
    new_list = sorted(lst)
    print('默认升序排序:',new_list)
    desc_list = sorted(lst,reverse=True)
    print('指定降序排序:',desc_list)
"""
列表生成式
"""
def create_test():
    lst = [i for i in range(1,10)]
    print(lst)
if __name__ == '__main__':
    create_test()

3.元组

# Author : zxy
# Date : 2022/5/3 21:52

# 元组
"""
什么是元组?
    Python 内置的数据结构之以,是一个不可变序列
不可变序列与可变序列
    不可变序列:字符串、元组
        不可变序列没有增、删、改的操作
    可变序列:列表、字典
        可变序列:可以对序列执行增、删、改操作,对象地址不发生改变
"""

# 1.元组的创建
"""
    1.1 直接小括号
        t = ('python','java')
    1.2 使用内置函数tuple()
        t = tuple(('python','java'))
    1.3 只包含一个元组的元素需要使用逗号和小括号
        t = (10,)
"""
def create_tuple():
    # 空列表创建
    lst = []
    lst = list()
    # 空字典创建
    dic = {}
    dic = dict()
    # 空元组创建
    tup = ()
    tup = tuple()
    t = ('python','java')
    print(t,type(t))
    t = tuple(('python', 'java'))
    print(t, type(t))
    t = (10,)
    print(t, type(t))
    # 如果不加逗号,会被识别为int类型
    t = (10)
    print(t, type(t))

# 2.为什么要将元组设计成不可变序列
"""
为什么要将元组设计成不可变序列
    在多任务环境下,同时操作对象时不需要加锁
    因此,在程序中尽量使用不可变序列
注意事项:
    元组中存储的是对象的引用
    a) 如果元组中对象本身是不可变对象,则不能再引用其他对象
    b) 如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
"""
def test():
    tup = (10,['a','b','c'],20)
    print(tup,'类型',type(tup))  # 元组类型
    print(tup[0],'类型',type(tup[0])) # 元组类型中的不可变对象
    print(tup[1],'类型',type(tup[1])) # 元组类型中的可变对象
    # tup[1]是list类型,可以增、删、改数据。但是不能将其改为tup[1]=100这种

# 3.元组的遍历
def list_tuple():
    print('--------------方式一:索引获取--------------------')
    tup = (10, ['a', 'b', 'c'], 20)
    print(tup[0])
    print(tup[1])
    # 但是这样的缺陷是,你要知道总共有多少数据
    print('--------------方式二:遍历查询----------------------')
    for item in tup:
        print(item)

# 主函数
if __name__ == '__main__':
    list_tuple()

4.字典

# Author : zxy
# Date : 2022/5/3 16:47

"""
字典:
    1.什么是字典
    2.字典得原理
    3.字典的创建与删除
    4.字典的查询操作
    5.字典的增删改
    6.字典推导式
"""
# 1.什么是字典
"""
    以Python内置的数据结构之一,与列表一样是一个可变序列
    以键值对的方式存储数据,字典是一个无序的序列
    eg: scores = {'张三':100,'李四':99}
        字典名:scores
        花括号:{}
        键:'张三'
        值:100
        冒号::
        逗号:,
"""

# 2.字典原理
"""
    
    字典的实现原理与查字典类似,查字典是先根据部首或拼音查找对应的页码,Python中的字典是根据Key查找Value所在位置
    
    字典元素的位置,不是按照输入的位置,是按照hash函数计算key的得到的
    key:不可变的序列
"""

# 3.字典的创建
def create_dict():
    list1 = ['张三','李四']
    list2 = [100,99]
    scores = {'张三':100,'李四':99}
    print('字典创建方式一:',scores)
    scores = dict(name='张三',age=18)
    print('字典创建方式二:',scores)
    scores = {list1:list2 for list1,list2 in zip(list1,list2)}
    print('字典创建方式三:',scores)

# 4.字典的查询
def get_dict():
    scores = {'张三': 100, '李四': 99}
    print('-----------------方式一和二的区别主要在于:方式一查找不存在的键会报错,方式二会返回一个None值')
    print('查找方式一',scores['张三'])
    print('查找方式二',scores.get('张三'))
    print('查找方式二,不存在的键:',scores.get('zxy'))
    print('查找方式二,不存在的键,修改默认返回值None:',scores.get('zxy',100))

# 5.字典的常用操作
"""
key的判断:in 或者 not in
字典的删除:del scores['张三']
字典的元素新增:scores['zxy']=100
"""
def operate_test():
# 判断是否存在
    scores = {'张三': 100, '李四': 99}
    print('判断张三是否存在:','张三' in scores)
    print('判断张三是否存在:', 'zxy' in scores)

# 删除元素
    del scores['张三']
    print("删除key='张三':",scores)

# 清空字典
    scores.clear()
    print('清空数据元素:',scores)

# 新增元素
    scores['zxy'] = 100
    print("增加key='zxy',value='100",scores)

# 修改元素
    scores['zxy'] = 99
    print('key是唯一的,如果重复新增,会覆盖原有值:',scores)

# 6.获取字典试图的三种方法
"""
    keys() 获取字典中所有key
    values() 获取字典中所有value
    items() 获取字典中所有key,value
"""
def view_test():
    scores = {'张三': 100, '李四': 99}
    keys = scores.keys()
    print('获取字典的所有key:',keys)
    values = scores.values()
    print('获取字典的所有value:',values)
    print('-----------------将key集合和list集合转成列表-----------------')
    print(list(keys),list(values))
    items = scores.items()
    print('获取字典中的所有key,value',items)
    print('--------------------将items转成元组tuple集合--------------')
    print(tuple(items))
# 7.循环字典元素
def list_dict():
    scores = {'张三': 100, '李四': 99}
    for item in scores:
        print('key=',item,'value=',scores[item])
        print('key=',item,'value=',scores.get(item))

# 8.字典的特点
"""
字典的特点:
    字典中所有元素都是一个key-value键值对,key不允许重复,value可以重复
    字典中的元素是无序的
    字典中的key必须是不可变对象
    字典也可以根据需要动态的伸缩
    字典会浪费较大的内存,是一种使用空间换时间的数据结构   *********************
"""

# 9.字典生成式
"""
内置函数zip()
    用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,
    然后返回由这些元组组成的列表
"""
def zip_dict():
    lst1 = ['张三','李四','王五']
    lst2 = [100,20,50]

    # 使用zip将两个列表,压缩成一个元组组成的列表
    dic1 = zip(lst1,lst2)
    print(list(dic1),type(dic1))

    # 使用zip元素,将两个元组,组成一个字典
    dic2 = {lst1:lst2 for lst1,lst2 in zip(lst1,lst2) }
    print(dic2,type(dic2))


# 主函数
if __name__ == '__main__':
    zip_dict()

5.生成式

# Author : zxy
# Date : 2022/5/4 10:27


# 列表生成式
list1 = [ i for i in range(6)]
print(list1,type(list1))

# 集合生成式
set1 = { i for i in range(6)}
print(set1,type(set1))

# 字典生成式
k = ['张三','李四']
v = [100,90]
dict1 = {k:v for k,v in zip(k,v)}
print(dict1,type(dict1))

6.总结

# Author : zxy
# Date : 2022/5/4 10:30

# 总结

"""
共有列表、字典、元组、集合
列表  []
字典  {key:value}
元组 ()
集合 {}
其中:
    列表、字典、集合都是可变的,元组不可变
    列表、元组可以有重复,集合不可以重复,字典的key不可以重复,value可以重复
    列表、元组是有序的,字典、集合是无序的

"""

# 1.元组
"""
创建元组:
    使用小括号()创建
    使用内置函数tuple()创建
元组遍历:
    for ... in 
不可变序列
"""

# 2.集合
"""
创建集合
    使用花括号{}
    内置函数set()
    集合生成式
集合遍历
    for ... in 
新增
    add()
    update()
删除
    remove()
    discard()
    pop()
    clear()
可变序列
"""

第六章

1.字符串常用操作

# Author : zxy
# Date : 2022/5/4 13:45

# 查询操作
"""
index() 查找字符第一次出现的位置,不存在抛出异常ValueError
rindex() 查找字符最后一次出现的位置,不存在抛出异常ValueError
find() 查找字符第一次出现的位置,不存在返回-1
rfind() 查找字符最后一次出现的位置,不存在返回-1
"""

def find_str():
    s = 'password'
    i = s.index('s')
    print('index查找字符第一次出现的位置,不存在抛出ValueError',i)
    i = s.find('s')
    print('index查找字符第一次出现的位置,不存在返回-1',i)
    i = s.find('z')
    print('index查找字符第一次出现的位置,不存在返回-1', i)
    j = s.rindex('s')
    print('index查找字符最后一次出现的位置,不存在抛出ValueError', j)
    j = s.rfind('s')
    print('index查找字符最后一次出现的位置,不存在返回-1', j)
    j = s.rfind('z')
    print('index查找字符最后一次出现的位置,不存在返回-1', j)

# 2. 字符串带小写转换
"""
upper() 把字符中的所有字符串都转成大写字母
lower() 把字符中的所有字符串都转成小写字母
swapcase() 把字符串中所有大写字母都转成小写字母,把所有小写字母转成大写字母
capitalize() 把第一个字符转成大写,其他转成小写
title() 把每个单词第一个字符转成大写,其余转成小写
"""
def trans_str():
    s = 'hEllo wOrd'
    print('原数据',s)
    print('upper():',s.upper())
    print('lower()',s.lower())
    print('swapcase()',s.swapcase())
    print('captitalize()',s.capitalize())
    print('title()',s.title())

# 3.字符串对齐方式
def align_str():
    s = 'hello word'
    print('居中对齐:',s.center(20,'-'))
    print('左对齐:',s.ljust(20,'_'))
    print('右对齐:',s.rjust(20,'_'))
    print('右对齐,只传一个参数,默认0填充',s.zfill(20))

# 4.字符串拆分
def split_str():
    s1 = 'hello world python'
    s2 = 'hello-world-python'
    print('从左往右分'.center(100,'*'))
    print('split默认按空格拆分',s1.split())
    print('split,设置sep选择分隔符,设置maxsplit设置最大分割次数', s2.split(sep='-',maxsplit=1))
    print('\n')
    print('从右往左分'.center(100, '*'))
    print('rsplit默认按空格拆分',s1.rsplit())
    print('rsplit,设置sep选择分隔符,设置maxsplit设置最大分割次数', s2.rsplit(sep='-', maxsplit=1))
    """从左往右和从右往左分的最主要的区别在与设置maxsplit后,会得到不同的结果"""

# 5. 字符串判断操作
"""
isidentifier()  是不是合法的标识符
isspace() 是否全部由空白字符串组成(回车、换行、水平制表符)
isalpha() 是否全部由字母组成
isdecimal() 是否全部由二进制数字组成
isnumeric() 是否全部由数字组成 
isalnum() 是否全部由字母和数字组成
"""
def judge_str():
    s1 = 'hello_123'
    s2 = s1.join('@')
    s3 = '      \t'
    s4 = 'abcd'
    s5 = '1234'
    s6 = '123四'
    print('合法标识符'.center(70,'*'))
    print(s1,'是不是由合法标识符组成',s1.isidentifier())
    print(s1,'是不是由合法标识符组成',s2.isidentifier())

    print('\n','空白字符串'.center(70, '*'))
    print(s1, '是不是空白字符串组成', s1.isspace())
    print(s3,'是不是空白字符串组成',s3.isspace())

    print('\n', '字母'.center(70, '*'))
    print(s1,'是不是全部由字母组成',s1.isalpha())
    print(s4, '是不是全部由字母组成', s4.isalpha())

    print('\n', '十进制数字'.center(70, '*'))
    print(s5,'是不是由十进制数字组成',s5.isdecimal())
    print(s6, '是不是由十进制数字组成', s6.isdecimal())

    print('\n', '数字'.center(70, '*'))
    print(s5, '是不是由数字组成', s5.isnumeric())
    print(s6, '是不是由数字组成', s6.isnumeric())

    print('\n', '字母和数字'.center(70, '*'))
    print(s1, '是不是全由字母和数字组成', s1.isalnum())
    print(s4,'是不是全由字母和数字组成',s4.isalnum())

# 6.字符串替换和 合并
def replace_join_str():
    s1 = 'hello java java'
    lst = ['hello','java','python']
    tup = ('hello','java','python')
    print('replace替换',s1.replace('java','python'))
    print('replace只替换1个目标',s1.replace('java','python',1))
    print('join合并','*'.join(s1))
    print('列表合并','*'.join(lst))
    print('元组合并','*'.join(tup))
if __name__ == '__main__':
    replace_join_str()

2.字符串比较操作

# Author : zxy
# Date : 2022/5/4 15:31

# 字符比较操作
"""
字符串的比较操作:
    运算符:> >= < <= == !=
比较规则:
    首先是比较两个字符串中第一个字符,如果相等则继续比较下一个字符,
    依次比较下去,直到两个字符串中的字符不相等时,其比较结果就说两个字符串的比较结果
    两个字符串中的所有后续字符将不再被比较
比较原理:
    两个字符进行比较时,比较是其ordinal value(原始值),调用内置函数ord可以 得到指定字符的Ordinal value。
    与内置函数ord对应的内置函数是chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
"""
def compare_str():
    print('python' > 'java')
    print('p',ord('p'))
    print('j',ord('j'))

    print('112',chr(112))
    print('106',chr(106))

    ## == 比较的值
    ## is 比较的id
if __name__ == '__main__':
    compare_str()

3.字符串切片操作

# Author : zxy
# Date : 2022/5/4 16:05

# 字符串切片操作
"""
字符串是不可变类型
    不具备增、删、改等操作
    切片操作将产生新的对象
"""
s = 'abcdefg'
print('指定切片区间',s[0:2])
print('不指定起始:',s[:2])
print('不指定结束:',s[2:])
print('指定区间、指定步长',s[0:3:2])

4.字符串编码解码

# Author : zxy
# Date : 2022/5/4 16:49

# 字符串的编码解码
"""
为什么需要字符串的编码转换:
    计算机之间的传输是通过byte字节,在计算机展示的时候是字符
编码和解码的方式:
    编码:将字符串转换为二进制数据bytes
    解码:将bytes类型的数据转换成字符串类型
"""

s = '大河向东流'

# 编码
print(s.encode(encoding='GBK')) # 一个中文字符,两个字节
print(s.encode(encoding='UTF-8')) # 一个中文字符,三个字节

# 解码
byte = b'\xb4\xf3\xba\xd3\xcf\xf2\xb6\xab\xc1\xf7'

print(byte.decode(encoding='GBK'))

byte = b'\xe5\xa4\xa7\xe6\xb2\xb3\xe5\x90\x91\xe4\xb8\x9c\xe6\xb5\x81'
print(byte.decode(encoding='UTF-8'))

5.字符串驻留机制

# Author : zxy
# Date : 2022/5/4 10:41

# 字符串的驻留机制
"""
字符串:
    在Python中字符串是基本数据类型,是一个不可变的字符序列
什么叫字符串驻留机制?
    仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中,
    Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同的字符串时,
    不会开辟新的空间,而是把该字符串 的地址赋给新创建的变量
"""
a = 'python'
b = "python"
c = """python"""
print('----------相同字符串,相同地址------------')
print(a,id(a))
print(b,id(b))
print(c,id(c))
print(a is b , b is c , c is a)

"""
驻留机制的几种情况:
    字符串长度为0或1时
    符合标识符的字符串
    字符串只在编译时进行驻留,而非运行时
    [-5,256]之间的整数数字
sys中intern方法强制2个字符串指向同一对象
pycharm对字符串进行了优化处理
"""

"""
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> s1 = 'abc'
>>> s2 = 'abc'
>>> s1 is s2
True
>>> s1 = 'abc%'
>>> s2 = 'abc%'
>>> s1 is s2
False
>>> s1 == s2
True
>>> 
"""


# 字符串驻留的优缺点
"""
字符串驻留的优缺点:
    当需要值相同的字符串时,可以直接从字符串池中拿来使用,
    避免频繁的创建和销毁,提升效率和节约内存,因此拼接字符串和修改字符串是比较影响性能的
    
    在需要进行字符串拼接的时候建议使用str类型的join方法,而非+,
    因为join()方法是先计算出所有字符中的长度,然后拷贝,只new一次对象,效率比+更高
"""
# >>> c = ''.join(['ab','c'])
# >>> c
# 'abc'
# >>> c = 'a'.join(['b','c'])
# >>> c
# 'bac'
# >>>

6.格式化字符串

# Author : zxy
# Date : 2022/5/4 16:21

# 格式化字符串
"""
格式化字符串的两种方式
    %作为占位符: '我的名字叫:%s,今年%d岁了' % (name,age)
        字符串:%s
        整数:%l 或 %d
        浮点数:%f
    {}作为占位符: '我的名字叫:{0},今年{1}岁了,我真的叫{0} format(name,age)
"""

name = 'zxy'
age = 18

print('我叫%s,我今年%d岁了' % (name,age))


print('我叫{0},我今年{1}岁了,我真的叫{0}'.format(name,age))


# 长度为10,保留小数点后三位
print('%10.3f' % 3.1415926)

print('{}'.format(3.1415926)) # 只有一个元素,不指定位置也可
print('{0:.3}'.format(3.1415926)) # 总共保留三位数
print('{0:.3f}'.format(3.1415926)) # 保留三位小数
print('{0:10.3f}'.format(3.1415926)) # 设置宽度和精度,一共十位,保留小数点后三位

第七章

1.函数

# Author : zxy
# Date : 2022/5/4 17:22

# 函数
"""
什么是函数:
    函数是执行特定任务和完成特定功能的一段代码
为什么需要函数:
    提高代码可复用性
    隐藏实现细节
    提高可维护性
    提高可读性
函数的创建:
    def 函数名([输入参数]):
        函数体
        [return xxxx]
"""

"""
    在函数调度过程中,进行参数的传递
    如果是不可变对象,在函数体的修改不会影响实参的值
    如果是可变对象,在函数体的修改会影响到实参的值
"""
def cale(a,b): # a,b为形参
    return a + b

if __name__ == '__main__':
    a = cale(10,20) # 10,20 是实参
    print(a)
    b = cale(b=100,a=10) # 指定参数赋值
    print(b)

2.函数返回值

# Author : zxy
# Date : 2022/5/4 18:55
# 函数返回值
"""
函数返回值:
    如果函数没有返回值 return可以不写
    函数的返回值,如果是一个,直接返回类型
    函数返回值,如果是多个,返回结果为元组
"""
# 函数返回多个值,结果为元组
def fun(num):
    odd = []
    even = []
    for i in num:
        if i % 2 == 0 :
            odd.append(i)
        else:
            even.append(i)
    return odd,even

if __name__ == '__main__':
    lists = [10,23,45,23,85,12]
    print('元组:',fun(lists))
    # 函数返回多个值,可以使用下标取值
    print('列表1',fun(lists)[0])
    print('列表2',fun(lists)[1])
    # for i,j in fun(10):
    #     print(i)
    #     print(j)

3.函数默认值

# Author : zxy
# Date : 2022/5/4 19:49


def fun(a,b=20):
    # 这里的为end='\t'也是给end指定传参,这样就不会使用默认值end='\n'
    # def print(self, *args, sep=' ', end='\n', file=None):
    print('begin1',end='\t')
    print('beigin2')
    return a+b

if __name__ == '__main__':
    a = fun(10)
    print('未给b传参,则b使用默认值',a)
    b = fun(10,30)
    print('给a,b指定传参,则默认值失效',b)

4.位置参数和关键字参数

# Author : zxy
# Date : 2022/5/4 20:01

# 函数得参数定义
"""
个数可变得位置参数:
    定义函数时,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
    使用*定义个数可变的位置形参
    结果为一个元组
个数可变的关键字形参:
    定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字形参
    使用**定义个数可变的关键字形参
    结果为一个字典
"""
def fun1(*args):
    print(args,type(args))

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

if __name__ == '__main__':
    fun1(10,20,30)
    fun2(a=10,b=20,c=30)

5.参数总结

# Author : zxy
# Date : 2022/5/4 21:07

# 参数总结

def fun(a,b,c):
    print('a={0},b={1},c={2}'.format(a,b,c))

def fun2(a,b,c,d):
    print('a={0},b={1},c={2},d={3}'.format(a, b, c,d))
if __name__ == '__main__':
    fun(10,20,30) # 位置传参
    fun(a=10,b=20,c=30) # 关键字传参
    lst = [10,20,30]
    fun(*lst) # 使用lst传参的时候,需要使用*,将列表中的元素依次传给函数fun()
    dic = {'a':10,'b':20,'c':30}
    fun(**dic)

6.变量的作用域

# Author : zxy
# Date : 2022/5/4 21:31

# 变量的作用域
"""
变量的作用域:
    程序代码能访问该变量的区域
    根据变量的有效范围可分为:
        局部变量:
            在函数内定义并使用的变量,只有在函数内部有效,
            局部变量使用global声明,这个变量就会变成全局变量
        全局变量:
            函数体外定义的变量,可作用于函数内外

"""
b = 'hello python'
def fun():
    a = 'hello word'
    global c
    c = 'hello java'
    print('局部变量',a)
    print('global局部变量转全局变量',c)
if __name__ == '__main__':
    print('全局变量', b)
    fun()
    # global将局部变量转为全局变量,定义在fun()函数中,需要先调用fun()函数,才能使用全局变量c
    print('global局部变量转全局变量',c)

7.递归函数

# Author : zxy
# Date : 2022/5/4 21:48

#递归函数
"""
什么是递归函数?
    如果在一个函数的函数体内调用了该函数本身,这个函数就成为递归函数
递归的组成部分?
    递归调用与递归终止条件
递归的调用过程?
    每递归调用一次函数,都会在栈内存分配一个栈帧
    每执行完一次函数,都会释放相应的空间
递归的优缺点?
    缺点:占用内存多,效率底下
    优点:思路和代码简单
"""

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


if __name__ == '__main__':
    print(fun(6))

8.斐波那契

# Author : zxy
# Date : 2022/5/4 22:09

# 斐波那契
"""
                                                fun(6)
                          fun(5)                                      fun(4)
              fun(4)                  fun(3)                  fun(3)              fun(2)
      fun(3)          fun(2)  fun(2)          fun(1)    fun(2)        fun(1)        .
fun(2)     fun(1)        .       .              .         .             .           .
.           .            .       .              .         .             .           .
.           .            .       .              .         .             .           .
1           1            1       1              1         1             1           1
"""
def fun(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fun(n-1) + fun(n-2)

if __name__ == '__main__':
    print(fun(6))

第八章

1.bug

# Author : zxy
# Date : 2022/5/4 22:35

# 1.规范操作
"""
1.漏末尾的冒号
2.缩进错误
3.英文字符写成中文
4.字符串连接,把字符串和数字拼接到一起
5.没有定义变量
6.比较运算符==和赋值运算符=的混用
"""

# 2.知识点不熟练导致错误
"""
1.索引越界:indexError
    lst = [11,22,33,44]
    print(lst[4])
2.append()方法使用不熟练
    lst=[]
    lst=append('A','B','C')
    print(lst)
"""

# 3.思路不清导致的问题
"""
基础知识不牢固,练
"""


'''列表套字典,字典里的value值有列表'''
lst = [{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆.罗宾斯','摩根.弗里曼']},
       {'rating':[9.6,1528760],'id':'1291546','type':['剧情','爱情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']},
       {'rating':[9.5,1559181],'id':'1292720','type':['剧情','爱情'],'title':'阿甘正传','actors':['汤姆.汉克斯','罗宾.怀特']}]

name = input('请输入你要查询演员的名字:')

for movie in lst:
    actor = movie['actors']
    for act in actor:
        if(name in act):
            print(name + '出演了' + movie['title'])


2.Python常见的异常类型

# Author : zxy
# Date : 2022/5/20 14:55


# Python常见的异常类型

ZeroDivisionError #除或取模零的类型
IndexError #序列中没有此索引
KeyError #映射中没有这个键
NameError #未声明/初始化对象(没有属性)
SyntaxError  #Python语法错误
ValueError #传入无效的参数

3.异常处理机制

# Author : zxy
# Date : 2022/5/20 14:05



# 1.try: ... except Error:...
"""
1.问题
程序代码逻辑没有错,只是因为用户错误操作或者一些例外情况而导致的程序崩溃
例如:除数不可以为0
     没有按照输入类型输入指定类型数据
2.解决
针对这种问题,Python提供了异常处理机制,可以在异常的时候出现0时即捕捉,然后内部"消化",让程序继续运行
    try ... except Error:
捕获异常的顺序按照先子类后父类的顺序,为了避免遗漏可能出现的异常,可以在最后增加BaseException
"""

try:
    n1 = int(input('请输入一个整数:'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
    print('结果为:',result)
except ZeroDivisionError:
    print('除数不可以为0')
except ValueError:
    print('值异常')

except BaseException as e:
    print(e)

# 2.try...except...else结构
"""
如果try块中没有抛出异常,则执行else,如果抛出异常,则执行except
"""

try:
    n1 = int(input('请输入一个整数:'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
except ZeroDivisionError:
    print('除数不可以为0')
else:
    print('结果为:',result)

# 3.try...except...else...finally
"""
finally块无论如何是否发生异常都会被执行,能常用来释放try块中申请的资源
"""
try:
    n1 = int(input('请输入一个整数:'))
    n2 = int(input('请输入另一个整数:'))
    result = n1 / n2
except ZeroDivisionError:
    print('除数不可以为0')
else:
    print('结果为:',result)
finally:
    print('无论是否抛出异常,都会执行finally,输出这一句')

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

4.TraceBack模块的使用

# Author : zxy
# Date : 2022/5/20 22:03

"""
使用traceback模块打印异常信息
"""
import traceback

try:
    print('测试'.center(10,'*'))
    print(1/0)
except:
    traceback.print_exc()

第九章

1.两大编程思想

# Author : zxy
# Date : 2022/5/20 22:14

"""
面向过程:
    事物比较简单,可以线性的思维去解决
面向对象:
    事务比较复杂,使用简单的线性思维无法解决
共同点:
    面向过程和面向对象都是解决实际问题的一种思维方式

联系:
    二者相辅相成,并不是对立的
    解决复杂问题,通过面向对象方式便于我们从宏观把握事务之间复杂的关系,
    方便分析整个系统;具体到微观操作,仍然使用面向过程来处理

"""

2.类和对象的理解

# Author : zxy
# Date : 2022/5/20 22:14

# 1.类和对象
"""
类:
    类是多个类似事物组成的群体的统称。能够帮助我们快速的理解和判断事物的性质
数据类型:
    不同数据类型属于不同的类
    使用内置函数type()查看数据类型
    例如:
        print(type(10))
        print(type(20))
对象:
    10,20都是Int类之下包含相似的不同个例,这个个例的专业术语称为实例或对象
"""


3.类和对象的创建

# Author : zxy
# Date : 2022/5/20 22:46


# 1.类的创建
"""Student为类的名称,由一个或多个单词组成,每个单词首字母大写,其余小写"""
class Student:
    # 直接写在类里的变量,称为类属性
    address = '上海'
    # name,age为实例属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 实例方法
    """在类之外定义的称为函数,在类之内定义的称为方法"""
    def info(self):
        print('name:',self.name,'age:',self.age)
    # 类方法
    @classmethod
    def cm(cls):
        print('类方法')
    # 静态方法
    @staticmethod
    def sm():
        print('静态方法')

# 2.对象的创建
"""
对象的创建又称为类的实例化
语法:
    实例名=类面()

"""
stu = Student('zxy','01')
print(stu.name)
print(stu.age)
stu.info() # 方法一:对象名.方法名()
Student.info(stu) # 方法二:类名.方法名(类的对象) -》 实际上就算定义处的self

4.类属性-类方法-静态方法

# Author : zxy
# Date : 2022/5/20 23:23

# 类属性、类方法、静态方法
"""
类属性:类中方法外的变量称为类属性,被该类所有对象共享
类方法:使用@classmethod修饰的主法,使用类名点直接访问的方法
静态方法:使用 @staticmethod修饰的主法,使用类名点直接访问的方法
"""

class Student:
    # 直接写在类里的变量,称为类属性
    address = '上海'
    # name,age为实例属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 实例方法
    """在类之外定义的称为函数,在类之内定义的称为方法"""
    def info(self):
        print('name:',self.name,'age:',self.age)
    # 类方法
    @classmethod
    def cm(cls):
        print('类方法')
    # 静态方法
    @staticmethod
    def sm():
        print('静态方法')


# 类属性调用
print(Student.address)
Student.address = '杭州'
print(Student.address)

# 类方法调用
Student.cm()

# 静态方法的调用
Student.sm()

5.动态绑定属性和方法

# Author : zxy
# Date : 2022/5/20 23:39

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

    def info(self):
        print('my name is ',self.name,', i am', self.age,' years old')

stu1 = Student('张三',20)
stu2 = Student('李四',30)
print('-----------------属性----------------------------')
print('为stu1动态绑定性别属性')
stu1.gender = '女'
print(stu1.name,stu1.age,stu1.gender)
print('为stu2动态绑定ID属性')
stu2.id = 100
print(stu2.name,stu2.age,stu2.id)
print('-----------------方法----------------------------')
def show():
    print('测试动态绑定方法')
stu1.show = show
stu1.show()

第十章

1.继承

# Author : zxy
# Date : 2022/5/21 10:01

# 继承
"""
父类:动物
子类:猫 、 狗 、 鸟继承动物的属性
如果一个类没有继承任何类,则默认继承Object
Python支持多继承
定义子类的时候,必须在其构造参数中调用父类的构造函数

"""

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名:{0},年龄:{1}'.format(self.name,self.age))

# 定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score = score

# 定义子类
class Teacher(Person):
    def __init__(self,name,age,subject):
        super().__init__(name,age)
        self.subject = subject


# 测试
stu = Student('zxy',1,100)
stu.info()

2.封装

# Author : zxy
# Date : 2022/5/20 23:57

# 面向对象的三大特征:
"""
封装:提高程序的安全性
    将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作,在类对象的外部调用方法
    这样就无需关系内部的具体实现细节,从而降低复杂度

    在Python中没有专门的修饰符用于属性的私有,如果该属性不希望在类对象外部被访问,前边使用两个"_"

继承:提高代码的复用性
多态:提高程序的可扩展性和可维护性
"""

# 封装
class Student:
    def __init__(self,name,age):
        self.name = name
        ## age前加两个下划线,表示不希望被类外使用
        self.__age = age
    def show(self):
        print('name is ', self.name,'age is ',self.__age)

# 使用封装方法
try:
    stu = Student('张三',20)
    stu.show()
    print(stu.name)
    print(stu.age)

except AttributeError:
    print("Error : 'Student' object has no attribute 'age'")

finally:
    """
    尽管在类中,age属性被添加两个下划线来表示不可被外部调用
    但是可以通过dir查看对象,发现_Student__age的属性
    """
    print(dir(stu))
    print(stu._Student__age)

3.多态

# Author : zxy
# Date : 2022/5/21 10:01

# 多态

"""
    简单的说,多态就算“具有多种形态”,它指的是:
即使不知道一个变量所引用对象到底是什么类型,仍然可以通过这个变量调用方法,在运行过程中根据变量所引用对象的类型,
动态决定调用哪个对象中的方法
"""

# 静态语言和动态语言
# 静态语言如Java
# 动态语言如Python
"""
静态语言实现多态的三个必要条件:
    1。继承
    2.方法重写
    3.父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”,当看到一只鸟走路像鸭子,游泳像鸭子,收起来像鸭子,那么这只鸟就可以被称为鸭子。
在鸭子的类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为
"""

4.方法重写

# Author : zxy
# Date : 2022/5/21 10:01

# 方法重写

"""
如果子类对继承的父类的某个属性或方法不满意,可以在子类中对其进行重写编写
子类重写后的方法中可以通过super().方法名()调用父类中被重写的方法
"""

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名:{0},年龄:{1}'.format(self.name,self.age))

# 定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score = score

    def info(self):
        super().info()
        print('成绩:{0}'.format(self.score))

# 定义子类
class Teacher(Person):
    def __init__(self,name,age,subject):
        super().__init__(name,age)
        self.subject = subject

    def info(self):
        super().info()
        print('学科:{0}'.format(self.subject))



# 测试
stu = Student('zxy',1,100)
stu.info()

tea = Teacher('Mr.zxy',2,'数学')
tea.info()


5.特殊属性

# Author : zxy
# Date : 2022/5/21 10:02

# 特殊方法和特殊属性

"""
特殊属性:
    __dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法:
    __len__() : 通过重写__len__()方法,让内置函数len()的参数可以是自定义类型
    __add__() : 通过重写__add__()方法,可以使用自定义对象具有'+'功能
    __new__() : 用于创建对象
    __init__() : 对创建的对象进行初始化

"""

class A(object):
    pass
class B(object):
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age

c = C('zxy',1)
print(c.__dict__) # 实例对象c所有属性的字典
print(C.__dict__) # 类

print(c.__class__) # 输出对象所属类
print(C.__bases__) # 输出C类的父类元素
print(C.__base__) # 输出C类的第一个父类元素
print(C.__mro__) # 查看类的层次结构
print(A.__subclasses__()) # 查看A的子类



6.特殊方法

# Author : zxy
# Date : 2022/5/21 12:12

# 特殊方法和特殊属性

"""
特殊属性:
    __dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法:
    __len__() : 通过重写__len__()方法,让内置函数len()的参数可以是自定义类型
    __add__() : 通过重写__add__()方法,可以使用自定义对象具有'+'功能
    __new__() : 用于创建对象
    __init__() : 对创建的对象进行初始化

"""

# 测试__add__()
a = 20
b = 30
c = a + b
d = a.__add__(b)  ## 调用a的对象__add__()方法

print(c)
print(d)

#  __len__() : 通过重写__len__()方法,让内置函数len()的参数可以是自定义类型
#  __add__() : 通过重写__add__()方法,可以使用自定义对象具有'+'功能
class Student():
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)

stu1 = Student('zzzz')
stu2 = Student('xx')

print('----------------------------__add__()------------------------')
stu3 = stu1 + stu2 # 重写__add__()方法
print(stu3)

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

print(len(stu3))


# __new__() : 用于创建对象
# __init__() : 对创建的对象进行初始化
print('----------------------------__new__()-----__init__()-----------------------------------')
class Person():
    def __new__(cls, *args, **kwargs):
        print('cls的id为{0}',id(cls))
        obj = super().__new__(cls)
        print('创建对象ID为{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('调用__init__(),self的ID值为{0}'.format(id(self)))
        self.name = name
        self.age = age

print('object类对象的ID为{0}'.format(id(object)))
print('Person类对象的ID为{0}'.format(id(Person)))

# 创建Person的实例对象
per = Person('zxy',1)
print('per这个实例对象的ID为{0}'.format(id(per)))

7.Object

# Author : zxy
# Date : 2022/5/21 10:01


# Object类
"""
    1.Object类 是所有类的父类,因此所有类都有Object类的属性和方法
    2.有内置函数dir()可以查看指定对象所有属性
    3.Object有一个__str__()方法,用于返回一个对于“对象的描述”,
对于内置函数str()经常用于print()方法,帮我们查看对象的信息,
所以我们经常对__str__()进行重写
"""
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print('姓名:{0},年龄:{1}'.format(self.name,self.age))
    def __str__(self):
        return '姓名:{0},年龄:{1}'.format(self.name,self.age)

obj = object()
print(dir(obj))

per = Person('zxy',1)
print(dir(per))
print(per) # 重写str方法,用于返回对象的描述

8.类的浅拷贝和深拷贝

# Author : zxy
# Date : 2022/5/21 15:22

# 类的浅拷贝和深拷贝

"""
变量的赋值操作
    只是形成两个变量,实际上还算指向同一个对象
浅拷贝:
    Python拷贝一般是浅拷贝,拷贝时,对象包含的子对象内容不拷贝。
因此,源对象与拷贝对象会引用捅一个子对象。
深拷贝:
    使用Copy模块的deepcopy函数,递归拷贝对象中包含的子对象,
源对象和拷贝对象所有的子对象也不相同

"""

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk

# 1.变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))

# 2.浅拷贝
import copy
disk = Disk()
com = Computer(cpu1,disk)
com2 = copy.copy(com)
# 浅拷贝,由com复制到com2,发生变化,而子对象disk和cpu不发生变化
print(com,com.cpu,com.disk)
print(com2,com2.cpu,com2.disk)


# 3.深拷贝

com3 = copy.deepcopy(com)
# 深拷贝,由com复制到com3,源对象和子对象都被拷贝,从而发生变化
print(com,com.cpu,com.disk)
print(com3,com3.cpu,com3.disk)

第十一章

1.主程序

# Author : zxy
# Date : 2022/5/21 16:35

# 以主程序运行
"""
    在每个模块的定义中都包括一个记录模块名称的变量__name__,程序可以
检查该变量,以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序
中执行,那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量值为__main__
"""

def add(a,b):
    return a + b

def div(a,b):
    try:
        return a/b
    except ZeroDivisionError:
        return 0

if __name__ == '__main__':
    print(div(1, 2))

2.包

# Author : zxy
# Date : 2022/5/21 16:42

# Python中的包
"""
包是一个分层次的目录结构,将一组功能相近的模块组织在一个目录下

作用:
    代码规范
    避免模块名称冲突

包与目录的区别:
    包含__init__.py文件的目录称为包,如chapter11/package
    目录里统称不包含__init__.py文件,如chapter11/dictory

包的导入:
    import 包名.模块名
"""

# 导入package包下的modeA模块
import package.modeA as pac

# 调用包下的modeA模块中的变量a
print(pac.a)

# 调用包下的modeA模块中的方法add()
print(pac.add(1, 2))



3.模块

模块的使用

# Author : zxy
# Date : 2022/5/21 16:26


# 自定义模块
"""
创建模块
    新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
导入模块
    import 模块名称 [as 别名]
    from 模块名称 import 函数/变量/类
"""
from math import pow

print(pow(2, 3))
# print(math.pi) 这里因为没有导入math模块中的pi,所以会报错

import math

print(math.pi)
print(dir(math))

自定义模块

# Author : zxy
# Date : 2022/5/21 16:12

# 自定义模块
"""
创建模块
    新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
导入模块
    import 模块名称 [as 别名]
    from 模块名称 import 函数/变量/类
"""

# 指定函数导入
from calc import add
print(add(1,2))

# 导入自定义模块calc的所有函数
import calc
print(calc.add(1,2))
print(calc.div(1,2))
print(calc.div(1,0))

calc

# Author : zxy
# Date : 2022/5/21 16:30

def add(a,b):
    return a + b

def div(a,b):
    try:
        return a/b
    except ZeroDivisionError:
        return 0

4.Python内置模块

# Author : zxy
# Date : 2022/5/21 17:15

#Python常用的内置模块

"""
sys 与Python解释器及其操作相关的标准库
time 提供与时间相关的各种函数的标准库
os  提供访问操作系统服务功能的标准库
calendar    提供与日期相关的各种函数的标准库
urllib  用于读取来自网上(服务器)的数据标准库
json    用于使用JSON序列化和反序列化对象
re      用于在字符串中执行正则表达式匹配和替换
math    提供标准算术运算函数的标准库
decimal     用于进行精度控制运算精度,有效数位和四舍五入操作的十进制运算
logging     提供了灵活的记录事件、错误、警告和调试信息等日志的功能
"""

import sys
import time
import urllib.request #爬虫常用
import logging
print(sys.getsizeof(20))

print('秒',time.time())
print(time.localtime(time.time()))

print(urllib.request.urlopen('http://www.baidu.com').read())


5.第三方模块的安装和使用

# Author : zxy
# Date : 2022/5/21 17:41


# 安装 pip install 模块名
# pip install schedule
# 使用 import 模块名

import schedule
import time

def run():
    print('python')

# 定时调度任务,每三秒执行一次
schedule.every(3).seconds.do(run)

while True:
    # 启动调度
    schedule.run_pending()
    # 每次执行后休息1秒
    time.sleep(1)

6.导入注意事项

# Author : zxy
# Date : 2022/5/21 17:08

# 导入模块和包的时候注意事项

# 使用import导入的时候,只能跟包名或模块名
import package
import 主程序

# 使用from ...  import导入的时候,可以跟包、模块、函数、变量
from package import modeA
from package.modeA import a
from package.modeA import add

第十二章

1.文件的读写原理

# Author : zxy
# Date : 2022/5/21 18:10

#文件的读写原理

"""
文件的读写俗称IO操作
文件读写操作流程
操作原理

Python操作文件-》打开或新建文件-》读写文件-》关闭资源

通过IO流将磁盘文件中的内容与程序中的对象中的内容进行同步
file = open( filename [,mode,encoding])
file: 被创建的文件对象
open: 创建文件对象的函数
filename: 要创建或打开文件名称
mode: 打开默认只读模式
encoding: 默认文本中字符编写格式为GBK
"""

file = open('file','r')
words = file.readlines()
print(words) # readlines读取到的是列表
file.close()

2.文件对象的常用方法

# Author : zxy
# Date : 2022/5/21 21:22

# 文件对象的常用方法
"""
read((size)) : 从文件读取size个字节或字符内容返回,若省略size,则一次性读完

readline() : 从文本文件中读取一行内容

readlines() : 把文本文件中每一行都作为独立的字符串对象,并将这些对象放入列表返回

write(str) : 将字符串str内容写入文件

writelines(list) : 将字符串列表list写入文本文件,不添加换行

seek(offset,[whence]) : 把文件指针移动到新的位置,offset表示相对于whence的位置
    offset:为正往结束放心移动
    whence不同的值代表不同含义:
        0 : 从文件头开始计算(默认值)
        1 : 从当前位置开始计算
        2 : 从文件尾开始计算

tell()
    返回文件指针的当前位置

flush()
    把缓冲区的内容写入文件,但不关闭文件

close()
    把缓冲区内容写入文件,同时关闭文件,释放文件对象相关资源
"""

3.常见文件打开方法

# Author : zxy
# Date : 2022/5/21 21:01

# 文件的类型
"""
按照文件中数据的组织形式,文件分为以下两大类:
    文本文件:通常以Unicode字符集存储,可以使用记事本程序打开,存储的是普通的字符文本
    二进制文件:把数据内容用字节存储,无法用记事本打开,必须使用专用的软件,比如mp3,jpg,doc等

打开模式:
    r : 只读模式,指针在文件开头
    w : 只写模式,存在则覆盖内容,不存在则创建,指针在文件开头
    a : 追加模式,存在则追加,指针在文件末尾、不存在则创建,指针在文件开头
    b : 以二进制方式打开文件,不能单独使用,需要与其他模式一起使用,rb 或者 wb
    + : 以读写方式打开文件,不能单独使用,需要与其他模式一起使用,a+
"""
# 只读
file = open('file','r')
words = file.readlines()
print(words)
file.close()

# 只写
file = open('file','w')
lst = ['床前明月光\n','疑似地上霜']
words = file.writelines(lst)
file.close()

# 追加
file = open('file','a')
lst = ['\n举头望明月']
words = file.writelines(lst)
file.close()

# 二进制文件边读边写
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()

4.OS

OS模块常用方法

# Author : zxy
# Date : 2022/5/21 21:51

# os模块
"""
    os模块是Python内置的与操作系统功能和文件系统相关的模块,
该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上
运行,得到的结果可能不一样

    os模块与os.path模块用于对目录或文件进行操作

    getcwd() 返回当前的工作目录
    listdir(path) 返回指定路径下的文件和目录信息
    mkdir(path,[mode]) 创建目录
    makedirs(path1/path2...) 创建多级目录
    rmdir(path) 删除目录
    removedirs(path1/path2...) 删除多级目录
    chdir(path) 设置path为当前工作目录
"""

import os

# 1.调用命令
# os.system('notepad.exe')
# os.system('calc.exe')

# 2.直接调用可执行文件
# os.startfile('D:\\WeChat\\WeChat.exe')

# 3.打开
print(os.getcwd())

# 4.查看指定目录下的文件
print(os.listdir('E:\\BigData\\date\\PyCharm\\May2\\chapter1'))
print(os.listdir('../chapter1'))

# 5.当前目录下创建\删除文件
os.mkdir('test1')
os.rmdir('test1')

# 6.多级目录创建\删除
os.makedirs('test1\\test2')
os.removedirs('test1\\test2')

# 7.修改当前工作目录
os.chdir('E:\\BigData\\date\\PyCharm\\May2\\chapter11')

os.path模块操作目录相关函数

# Author : zxy
# Date : 2022/5/21 22:10

# os.path 模块操作目录相关函数
"""
abspath(path) 用于获取文件或目录的绝对路径
exists(path) 用于判断文件或目录是否存在,如果存在返回True,否则返回False
join(path,name) 将目录与目录或文件名拼接起来
splitext() 分离文件名和扩展名
basename(path) 从一个目录中提取文件名
dirname(path) 从一个路径中提取文件路径,不报错文件名
isdir(path) 用于判断是否为路径
"""

import os.path as  path

# 1.绝对路径
print(path.abspath('..'))
# 2.是否存在
print(path.exists('/chapter12'))
# 3.分割
# 3.1 分割目录和文件
print(path.split('/chapter12'))
# 3.2 分割文件名和扩展名
print(path.splitext('chapter12.py'))
# 4.分离文件名
filename = path.basename('/chapter12')
print(filename)

# 5.分离目录
dirname = path.dirname('/chapter12')
print(dirname)

# 6.将目录和文件名连接
print(path.join(dirname, filename))

# 7.是否为路径
print(path.isdir('/chapter12'))
print(path.isdir('chapter12'))

案例_列出指定目录下所有py文件

# Author : zxy
# Date : 2022/5/21 22:38

import os

path = os.getcwd()
lst = os.listdir('E:/BigData/date/PyCharm/May2/chapter12')
lst_files = os.walk('E:/BigData/date/PyCharm/May2/chapter12')
for filename in lst:
    # 方法一:os.path模块实现
    """
    fileSplit = os.path.splitext(filename)
    if fileSplit[1] == '.py':
        print(filename)
    """
    # 方法二:
    if filename.endswith('.py'):
        print(filename)


# 2.递归遍历
print('递归遍历'.center(100,'*'))
for dirpath,dirname,filename in lst_files:
    # filename 是递归目录下的文件列表
    for file in filename:
        if file.endswith('.py'):
            print(file)

    """
    代码:
    
    print(dirpath)
    print(dirname)
    print(filename)
    print('------------')
    
    输出结果:
    
    E:/BigData/date/PyCharm/May2/chapter12
    ['os']
    ['Copy.png', 'copy2.png', 'CSDN.png', 'file', 'with语句.py', '常见文件打开模式.py', '文件对象的常用方法.py', '文件的读写原理.py', '编码格式.py']
    ------------
    E:/BigData/date/PyCharm/May2/chapter12\os
    []
    ['ospath模块操作目录相关函数.py', 'os模块常用函数.py', '案例_列出指定目录下所有py文件.py']
    ------------
    """

5.with语句

# Author : zxy
# Date : 2022/5/21 21:39

# With语句
"""
    with语句可以自动管理上下文资源,不论什么原因跳出with块,
都能确保文件正确的关闭,以此来达到释放资源的目的
"""

# 离开了with,就自动关闭文件
# 遵循上下文管理协议
with open('file','r') as read_file:
    print(read_file.read())

# 使用with语句重写,二进制文件边读边写
with open('copy.png','rb') as read_png:
    with open('copy2.png','wb') as write_png:
        write_png.write(read_png.read())

"""
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()
"""

6.编码格式

# Author : zxy
# Date : 2022/5/21 17:54

# 编码格式
"""
Python的解释器使用的Unicode(内存)
.py文件在磁盘上使用UTF-8存储(外存),如果需要修改存储类型,在.py文件开头第一行写:#encoding=gbk
"""

# GBK和UTF-8
"""
GBK英文一个字节,汉字两个字节
UTF-8英文一个字节,汉字三个字节
"""


Python十四案例

1.ASCII码

# Author : zxy
# Date : 2022/5/24 23:10

a = 97
for i in range(0,26):
    print(chr(a+i),'----->',a+i)

2.enumerate函数

# Author : zxy
# Date : 2022/5/24 23:27
# Desc : enumerate函数,用于获取列表索引和数据

# 1.列表
year = [82,89,88,86,85,00,99]
print('原列表:',year)

for index,value in enumerate(year):
    if str(value) != '0':
        year[index] = int('19'+str(value))
    else:
        year[index] = int('200'+str(value))

print('调整后:',year)

# 2.元组
coffice_name = ('蓝山','卡布奇诺','拿铁','皇家咖啡')
print('您好,欢迎光临')
print('本店经营的咖啡有:')
for index,item in enumerate(coffice_name):
    print(index+1,'.',item,end=' ')

buy = int(input('\n请输入你想购买的品类:'))
print('你购买的[',coffice_name[buy-1],']咖啡已到货!')

3.wordcount

# Author : zxy
# Date : 2022/5/26 14:24
def wordcount(words,word):
    count = 0
    for item in words:
        if word.upper() == item or word.lower() == item:
            count += 1
    return count

if __name__ == '__main__':
    words = 'helloworldhellopythonhelloJava'
    word = 'h'
    count = wordcount(words,word)
    print(count)

4.修改字体输出颜色

# Author : zxy
# Date : 2022/5/23 23:14
# Desc : 控制输出颜色

# 格式:
#   设置颜色开始 :\033[显示方式;前景色;背景色m
# 说明:
# 前景色            背景色           颜色
# ---------------------------------------
# 30                40              黑色
# 31                41              红色
# 32                42              绿色
# 33                43              黃色
# 34                44              蓝色
# 35                45              紫红色
# 36                46              青蓝色
# 37                47              白色
# 显示方式           意义
# -------------------------
# 0                终端默认设置
# 1                高亮显示
# 4                使用下划线
# 5                闪烁
# 7                反白显示
# 8                不可见

print('\033[0:35m\t\tPython切换颜色打印\033[m')

print('\033[0:32m\t\tPython切换颜色打印\033[m')



5.列表倒叙输出

# Author : zxy
# Date : 2022/5/26 12:45
# Desc : 列表倒序输出

card = ['1001','1002','1003','1004']

print('正序输出...')
for i in card:
    print(i)

print('倒叙输出...')
# 从len(card)-1 到 -1依次输出,步长为-1
for i in range(len(card)-1,-1,-1):
    print(card[i])

6.十进制转二八十六

# Author : zxy
# Date : 2022/5/23 23:48
# Desc : 十进制转二进制、八进制、十六进制

def cale():
    number = int(input('请输入一个十进制数字:'))

    print('你输出的十进制数字为:{}'.format(number))
    print('你输出的二进制数字为:{}'.format(bin(number)))
    print('你输出的八进制数字为:{}'.format(oct(number)))
    print('你输出的十六进制数字为:{}'.format(hex(number)))

if __name__ == '__main__':
    while True:
        try:
            cale()
            break
        except:
            print('你输入有误!!!请重写输入')

7.向文件输入语句

# Author : zxy
# Date : 2022/5/23 21:15
# Desc : 向文件中输入语句

# 方式一:使用print方式输出文字,目的地是文件
fp = open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test1.txt','w')

print('Good Good Study,Day Day Up',file=fp)

fp.close()

# 方式二:是哦那个with上下文管理器
with open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test2.txt','w') as file:
    file.write('好好学习,天天向上')

8.字符串分割

# Author : zxy
# Date : 2022/5/28 0:42

class Student(object):
    def __init__(self,stu_name,stu_age,stu_gender,stu_score):
        self.stu_name = stu_name
        self.stu_age = stu_age
        self.stu_gender = stu_gender
        self.stu_score = stu_score

    def show(self):
        print(self.stu_name,self.stu_age,self.stu_gender,self.stu_score)

# 列表中存储对象,然后通过对象调用类中函数
if __name__ == '__main__':
    print('请输入五位学生信息,(姓名-年龄-性别-成绩)')
    lst = []
    for i in range(0,2):
        s = input(f'请输入入第{i+1}位学生的信息和成绩:')
        s_lst = s.split('-')
        stu = Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
        lst.append(stu)

    for item in lst:
        item.show()

9.异常抛出

# Author : zxy
# Date : 2022/5/26 14:52
# 手动抛出异常: raise Exception('')
# 自动抛出异常: try...except...

score = int(input('请输入一个分数:'))
try:
    if 0 <= score <= 100:
        print('分数为:',score)
    else:
        raise Exception('分数超出范围!!!')
except Exception as e:
    print(e)

10.格式化字符串输出

# Author : zxy
# Date : 2022/5/23 23:28
# 格式化字符串输出

height = 170

weight = 50.5

bmi = weight / (height + weight)

# 6种格式化方式
print('身高',height,'的你体重',weight)
print('身高'+str(height)+'的你体重'+str(weight))
print('身高{0}的你体重{1}'.format(height,weight))
print(f'身高{height}的你体重{weight}')
print('身高%s的你体重%s' % (height,weight))

print('你的BMI指标是:' + '{:0.7f}'.format(bmi))

11.格式化时间类型

# Author : zxy
# Date : 2022/5/28 11:00
import time

if __name__ == '__main__':
    print(time.time())
    print(time.localtime(time.time()))
    print(time.strftime('%Y-%m-%d  %H:%M:%S',time.localtime(time.time())))

12.登录支付功能

# Author : zxy
# Date : 2022/5/24 0:07
# Desc : 验证登录用户名,密码;设置限制支付密码只允许是数字

def login(username,password):
    if username == 'admin' and password == '123456':
        print('登录成功!!')
        return True

if __name__ == '__main__':
    while True:
        username = input('请输入用户名:')
        password = input('请输入密码:')
        if login(username,password):
            pay = input('请输入支付密码:')
            """
            if条件成立,则将开头的字符串输出,否则输出else后的字符
            """
            print('支付密码合法' if pay.isdigit() else '支付密码不合法,只能由数字组成!!')
            break

        else:
            print('账号密码错误,请重新登录!!!')

13.遍历两个列表输出

# Author : zxy
# Date : 2022/5/23 21:22
# Desc : 循环遍历两个列表中数据

# 1.列表输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']

for i in range(len(lst_type)):
    print(lst_type[i],':',lst_data[i])

# 2.字典输出
dic_data = {'id':'001','name':'zxy','age':'5'}
for i in dic_data:
    # print(i, ':', dic_data[i])
    print(i,':',dic_data.get(i))

# 3.列表转元组输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']

for i,j in zip(lst_type,lst_data):
    print(i,':',j)


# 4.列表转字典输出
dict_list = dict(zip(lst_type, lst_data))
for i in dict_list:
    print(i,dict_list[i])

14.列表

# Author : zxy
# Date : 2022/5/26 14:10


phones = set()

for i in range(5):
    info = input(f'请输入第{i+1}个朋友的姓名和手机号:')
    phones.add(info)

for item in phones:
    print(item)

Logo

旨在为数千万中国开发者提供一个无缝且高效的云端环境,以支持学习、使用和贡献开源项目。

更多推荐