[Python知识库]Python （杨淑娟老师基础课程巩固）

#一个变量由三部分组成，标识，类型，值
#==比较的是值
#比较对象的标识使用 is

#a=10
#b=10
#print(a==b)
#print(a is b)

#数据输出文中，注意点1所指定的盘符在存在2使用file =fp;3如果文件不存在就创建，存在及在文件内容的后面继续追加
#什么是转义字符呢 就是反斜杠+想要实现的转转义功能首字母
#当字符串中包含反斜杠，单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义
#当字符串中包含换行，回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符

'''print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')
print('hello\rworld')#world 将hello进行了覆盖
print('hello\bworld')#\b是退一个格，将o退没了
print('http:\\\\www.baidu.com')
print('老师说:\'大家好\'')

#原字符，不希望字符串中的转义符起作用，就使用原字符，就说在字符串之前加上r或R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠
#print(r'hello\nworld\')
#二进制以ob开头，八进制以Oo开头，十六进制以ox开头，十进制是默认的进制

#位运算符 将数据转成二进制进行计算 位运算符
#位与&----》对应数位都是1，结果数位才是1，否则为0
#位或|---->对应数位都是0，结果数位才是0，否则为1
#左移位运算符《---->高位溢出舍弃，低位补0，相当于乘以2
#右移位运算符》---->低位溢出舍弃，高位补0，相当于除以2'''

#字符串类型中单引号和双引号定义的字符串必须在一行，三引号定义的字符串可以分布在连续的多行

name='张三'
age=20
print(type(name),type(age))
print('我叫'+name+'今年'+str(age)+'岁')#当将str类型与int类型进行连接时，报错，解决方案，类型转换

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

#从键盘录入两个整数，计算两个整数的和
'''a=input('请输入一个加数：')
a=int(a)
b=input('请输入另一个加数：')
b=int(b)
print(type(a),type(b))
print(a+b)'''
#上述是一种方法，下面是第二种方法
'''a=int(input('请输入一个加数：'))

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

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

'''print(11//2) #5 整除运算，一正一负向下取整
print(1/2) #除法运算
print(11%2) #取余运算 余数=被除数-除数*商（一正一负取余公式）
print(2**3) #表示的是2的三次方'''

'''print('-----------交换两个变量的值-------')
a,b=10,20
print('交换之前:',a,b)
a,b=b,a
print('交换之后',a,b)'''

#比较运算符的结果为BooL类型
'''false、0、0.0、None、' '、“ ”、 []空列表 、()空元组,dict()、{}是空字典，set()是空集合。这些Bool值都是false'''

'''money=1000
s=int(input('请输入取款金额'))
if money>=s:
     money=money-s
     print('取款成功，余额为:',money)'''

'''num=int(input('请输入一个整数'))
if num%2==0:
     print(num,'是偶数')
else:
   print(num,'是奇数')'''

'''#多分支结构
score=int(input('请输入一个成绩:'))
if score>=90 and score<=100:
     print('A级')
elif score>=80 and score<=89:
     print('B级')
elif score>=70 and score<=79:
     print('C级')
elif score>=60 and score<=69:
     print('D级')
elif score>=0 and score<=59:
     print('E级')
else:
     print('对不起，成绩有误，不在成绩的有效范围')'''

'''answer=input('请问您是会员吗y/n')
money=float(input('请输入您的购物金额:'))
if answer=='y':
    if money>=200:
        print('打8折，付款金额为:',money*0.8)
    elif money>=100:
        print('打9折，付款金额为:',money*0.9)
    else:
        print('不打折，付款金额为:',money)
else:
        if money>=200:
            print('打95折，付款金额为:',money*0.95)
        else:
            print('不打折，付款金额为:',money)'''

'''num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于',num_b)
第二种方法
print('使用条件表达式进入比较')
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))'''

'''age=int(input('请输入您的年龄'))
if age:
    print(age)
else:
    print('年龄为',age)'''

''''#range()函数，用于生成一个整数序列，返回值是一个迭代器对象，该函数的优点，不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同，
因为仅仅存储start stop step。只有当用到range对象时，才会去计算序列的相关元素 in 与not in 判断整数序列中是否存在（不存在）指定的整数'''

'''r=range(10)
print(r)
print(list(r))

r=range(1,10)
print(list(r))'''


'''4步循环法
1初始化变量
2条件判断
3条件执行体（循环体）
4改变变量
总结：初始化的变量与条件判断的变量与改变的变量为同一个'''

for _ in range(5):
    print('人生苦短，我用Python')

 print('使用for循环，计算1-100之间的偶数和')

 sum=0
 for item in range(1,101):
        if item %2==0:
            sum+=item
            print('1到100之间的偶数和为:',sum)

f                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            or _ in range(5):
    print('人生苦短，我用Python')

print('使用for循环，计算1到100之间的偶数和')
sum=0
for item in range(1,101):
    if item %2==0:
        sum+=item

print('1到100之间的偶数和为:',sum)'''

'''sum=0
a=0
while a<5:
    sum+=a
    a+=1
    print('和为',sum)'''

'''sum=0
a=1

while a<=100:
    if not bool(a%2):
         sum+=a

    a+=1
    print('1-100之间的偶数和',sum)'''

'''for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    print(ge,shi,bai)'''

#从键盘录入密码，最多录入三次，如果正确就结束循环
'''for item in range(3):
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')'''
#第二种方法
'''a=0
while a<3:
    pwd = input('请输入密码:')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

        a+=1
else:
        print('对不起，三次密码均输入错误')'''
#第一种方法采用else语句
'''for item in range(3):
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')'''

#要求输出1到50之间所有5的倍数
'''for item in range(1,51):
    if item%5==0:
        print(item)
print('----------使用continue---------')
for item in range(1,51):
    if item%5!=0:
        continue
        print(item)'''

'''for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j, end='\t')
    print()'''

'''for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')
    print()'''

列表的特点

1列表元素按顺序有序排序2索引映射唯一个数据3列表可以存储重复数据4任意数据类型混存5根据需要动态分配不回收内存

列表的查询操作

1获取列表中指定元素的索引 index(){1如果列表中存在N个相同元素，只返回相同元素中的第一个元素的索引2如果查询的元素在列表中不存在，则会抛出ValueError3还可以在指定的start和stop之间进行查找

2获取列表中的单个元素 list[] 若是指定索引不存，抛出indexError

语法格式

列表名[start:stop:step]

判断指定元素在列表中是否存在

元素 in 列表名

元素 not in 列表名

列表元素的遍历

for 迭代变量 in 列表名

列表元素的增加操作

append()? 在列表的末尾添加一个元素

例如：

list=[10,20,30]

print('添加元素之前',list,id(lst))

lst.append(100)

print('添加元素之后',list,id(lst))

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

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

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

列表元素的删除操作

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

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

切片 一次至少删除一个元素

clear() 清空列表

del 删除列表

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

lst.pop(1)#根据索引移除元素
print(lst)
lst.pop()
print(lst)

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

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

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

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

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

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

列表生成式

语法格式：[i*i for i in range(1,10)]

注意事项:表示列表元素的表达式中通常包含自定义变量

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

字典

Python内置的数据结构之一，与列表一样是一个可变序列；以兼职对的方式存储数据，字典是一个无序的序列

列表是用方括号进行填充，字典是用花括号进行填充

字典的实现原理：字典的实现原理是根据key查找value所在的位置

字典的创建

最常用花括号

scores={'张三':100}

使用内置函数dict()

dict(name='jack',age=20)

字典中元素的获取有1 []取值和2 使用get()取值的区别

[] 如果字典中不存在指定的Key,抛出Keyerror异常

get()方法取值，如果字典中不存在指定的Key，并不会抛出KeyError而是返回None,可以通过参数设置默认的value，以便指定的key不存在

获取字典视图的三个方法

1keys() 获取字典中所有Key

2 values() 获取字典中所有value

3 items()? 获取字典中所有key.value对

scores={'张三':100,'李四':98,'王五':45}
#获取所有的Key
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys))

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

#获取所有的Key-value对
items=scores.items()
print(items)
print(list(items)) #转换之后的列表元素是由元组组成
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

字典的特点

字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

字典中的元素是无序的

字典中的Key必须是不可变对象

字典也可以根据需要动态地伸缩

字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

内置函数zip（）用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

items=['Fruits','Books','Others']

prices=[96,78,85]

lst=zip(items,prices)

print(list(lst))

元组

Python 内置的数据结构之一，是一个不可变序列

不可变序列与可变序列

不可变序列：字符串和元组 不可变序列没有增删改操作

可变序列：列表，字典 可以对序列执行增删改操作，对象地址不发生改变

元组的创建方式

直接小括号

t=('python','hello',90)

使用内置函数tuple(('python','hello',90))

只包含一个元组的元素需要使用逗号和小括号

t=(10, )

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

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

驻留机制的交互模式

1字符串的长度为0或1

2符合标识符的字符串

3字符串只在编译时进行驻留，而非运行时

4[-5,256]之间的整数数字

sys中的Intern方法强制2个字符串指向同一个对象

pycharm对字符串进行了优化处理

字符串驻留机制的优缺点

当需要值相同的字符串时，可以直接从字符串池里拿出使用，避免频繁的创建和销毁，提升效率和节约内存

在需要进行字符串拼接时建议使用str类型的join方法，而非+,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只New一次对象，效率要比+效率高

字符串的查询操作的方法

Index()查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

rindex()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

find()查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1

rfind()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

字符串的大小写转换操作

1uper()把字符串中所有字符都转成大写字母

2lower（）把字符串中所有字符都转成小写字母

3 swapcase() 把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

4 capitalize() 把第一个字符串转换为大写，把其余字符转成小写

5title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

集合set是可变的，不可重复的无序的，定义符号是{}

center() 居中对齐

ljust() 左对齐

rjust() 右对齐

zfill（） 右对齐

split() 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回值都是一个列表

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

rsplit() 从字符串的右边开始劈分

判断字符串操作的方法

1isidentifier() 判断是否是合法的标识符

2 isspace() 判断是否由空白字符组成

3 isalpha() 判断是否由字母组成

4 isdecimal() 判断是否全部由十进制的数字组成

5 isnumeric() 判断是否全部由数字组成

6 isalnum() 判断是否由字母和数字组成

字符串替换

replace() 第一个参数指定被替换的子串，第2个参数指定替换子串的字符串

join() 将列表或元组中的字符串合并成一个字符串

字符串的比较操作

比较规则： 首先比较两国字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两国字符串的比较结果，两个字符串中的所有后续字符将不再被比较结果，两个字符串中的所有后续字符将不再被比较

比较原理：两个字符进行比较时，比较的是其ordinal value(原始值)，调用内置函数Ord 可以，得到指定字符的ordinal value? 与内置函数Ord对应的是内置函数chr，调用内置函数chr时指定ordinal value 可以得到其对应的字符

字符串的切片操作

字符串是不可变类型。不具备增、删、改等操作

切片操作将产生新的对象

格式化字符串

1 %作占位符

2 {} 作占位符

name='张三'

age=20

print('我叫%s，今年%d岁' %（name,age）)

print('我叫{0},今年{1}岁‘，format(name,age))

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

字符串的编码转换

需要字符串的编码转换

编码与解码的方式 编码：将字符串转换为二进制数据bytes

解码： 将bytes 类型的数据转换成字符串类型

函数是执行特定任和以完成特定功能的一段代码

函数可以复用代码，隐藏实现细节，提高可维护性，提高可读性便于调试

函数的创建 def 函数名（[输入参数]):

? ? ? ? ? ? ? ? ? ? ?函数体

? ? ? ? ? ? ? ? ? ?[retrurn xxx]

在函数调用过程中，进行参数的传递

如果是不可变对象，在函数体的修改不会影响实参的值

如果是可变对象，在函数体的修改会影响到实参的值。

函数返回多个值时，结果为元组

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

2函数的返回值，如果是1个，直接返回类型

3函数的返回值，如果是多个，返回的结果是元组

函数的参数定义

函数定义默认值参数

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

个数可变的位置参数

定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数

使用*定义个数可变的位置形参

结果为一个元组

个数可变的关键字形参

定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参

使用**定义个数可变的关键字形参

结果为一个字典

函数调用时的参数传递，称为位置传参

在函数调用时，将列表中的每个元素都转换为位置实参传入

函数的调用，所以是关键字实参

在函数调用时，将字典中的键值对都转换为关键字实参传入

变量的作用域

程序代码能访问该变量的区域

根据变量的有效范围可分为?

局部变量

? ? ? ?在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明

全局变量

? ? ? ?函数体外定义的变量，可作用于函数内外

递归函数

? ? ? ? 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

递归的组成部分

? ? ? ? ?递归调用与递归终止条件

递归的调用过程

? ? ? ? 每递归调用一次函数，都会在栈内存分配一个栈帧

? ? ? ? 每执行完一次函数，都会释放相应的空间

递归的优缺点

? ? ? ? ? ? ? 缺点：占用内存多，效率低下

? ? ? ? ? ? ?优点：思路和代码简单

Python的异常处理机制

多个except结构

? ?捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException

Try...except...else结构

? ? ? ?如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块

Python常见的异常类型

? ? ? ? ? ZeroDivisionError? ? ? ? 除（或取模）零（所有数据类型）

? ? ? ? ? ?IndexError? ? ? ? ? ? ? ? ?序列中没有此索引（index)

? ? ? ? ? ? KeyError? ? ? ? ? ? ? ? ?映射中没有这个键

? ? ? ? ? ?NameError? ? ? ? ? ? ?未声明/初始化对象（没有属性）

? ? ? ? ? ?SyntaxError? ? ? ? ? ? ?Python 语法错误

? ? ? ? ? ? ValueError? ? ? ? ? ? ?传入无效的参数

traceback模块

使用traceback模块打印异常信息

面向过程? 事务比较简单，可以用线性的思维取解决

面向对象? 事务比较复杂

类

类是多个类似事物组成的群体的统称，能够帮助我们快速理解和判断事物的性质

数据类型 不同的数据类型属于不同的类，使用内置函数查看数据类型

对象

100、99都是int类之下包含的相似的不同个例，这个个例专业数语称为实例或对象

创建的类语法

class Student:

? ? ? ? ?pass

类的组成包括类属性，实例方法，静态方法，类方法

对象的创建称为类的实例化

有了实例，就可以调用类中的内容

类属性：类中方法外的变量称为类属性，被该类的所有对象所共享

类方法： 使用@classmethod修饰的方法，使用类名直接访问的方法

静态方法： 使用@staticmethod修饰的主法，使用类名直接访问的方法

Python是动态语言，在创建对象之后，可以动态地绑定属性和方法

封装

面向对象的三大特征

? ? ? ? 封装：提高程序的安全性

? ? ? ? ? ? ? ? ? ?将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法，这样，无需关心方法内部的具体实现细节，从而隔离了复杂度

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

? ? ? ? ?继承：提高代码的复用性

? ? ? ? ? ? ? ? ? 如果一个类没有继承任何类，则默认继承object

? ? ? ? ? ? ? ? Python支持多继承 定义子类时，必须在其构造函数中调用父类的构造函数

? ? ? ? 多态：提高程序的可扩展性和可维护性

? ? ? ? ? ? ? ? ? ?

? ? ? ??

? ? ? ? ? ? ?方法重写

? ? ? ? ? ? ? ? ? ? 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写

? ? ? ? ? ? ? ? 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

object类

? ? ? ? ? object类是所有类的父类，因此所有类都有object类的属性和方法

? ? ? ? ? ? 内置函数dir()可以查看指定对象所有的属性

? ? ? ? ? ? Object有一个_str_()方法，用于返回一个对于”对象的描述“，对应于内置函数str()经常用于print()方法，帮我们查对象的信息，所以我们经常会对_str_进行重写

? ? ? ?

多态

? ? ? ? 多态是指即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法

静态语言和动态语言关于多态的区别

? ? ? ? ?静态语言实现多态的三个必要条件（继承，方法重写，父类引用指向子类对象)

? ?变量的赋值操作

? ? ? ? ? ? ? ? 只是形成两个变量，实际上还是指向同一个对象

? ? 浅拷贝

? ? ? ? ? ? ? Python拷贝一般都是浅拷贝，拷贝时对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

? ?深拷贝

? ? ? ? ? ? ? ? ?使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

包含_init_.py文件的目录称为包

目录里通常不包含_init_.py文件

Python的解释器使用的是Unicode（内存）

?.py文件在磁盘上使用UTF-8存储（外存）

内置函数open()创建文件对象

文件类型：文本文件：默认为Unicode字符集，可以使用记事本程序打开

? ? ? ? ? ? 二进制文件：把数据内容用字节进行存储，必须用专门的软件打开

? ? ? ? ? ?

??

? ??