Python学习

#可以输出字符串
print("HEllo eorld")

#含有运算符的表达式
print(3+1)

#数据输出文件中   注意点1，所指定的盘符要存在，2要使用file=fp
fp=open('E:/text.text','a+')  #如果文件不存在就去创建，如果存在就继续追加
print('hellow world',file=fp)
fp.close()

#不进行换行输出
print('hello world','Python',"你好")

2，转义字符

就是反斜杠+想要实现的转义功能首字母

print(('hellooooo\tworld'))
print(('hello\rworld'))    #r表示回车 从头开始
print(('hello\bworld'))    #b 表示退一个格  没有o了

\t 是每个输出值空一格
print('http:\\www.baidu.com')  #进行输出的时候遇见两个\最终会以一个\显示
print('http:\\\\www.baidu.com')

print('老师说：‘大家好\'')  #想在输出的结果中出现单引号，那就输出一个反斜线就行 这就是转义字符

#不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r或R
print(r'hello\nworld')   #\n就不起作用了
#注意事项，最后一个字符不能是\，两个可以

hellow
world
hello world
hellooooo world
world
hellworld
http:\www.baidu.com
http:\\www.baidu.com
老师说：‘大家好'
hello\nworld

3，二进制与字符编码

8个位子是一个字节byte

1024byte=1KB

8个位置可以表示256种状态

也就ASCII表共有256种状态

4，Python当中的标识符与保留字

Pyton的规矩

保留字有些单词我们是不能用的

['False', 'None', 'True', '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']

Process finished with exit code 0

自己命名的就为标识符：

不能以数字开头，

不能是我们的保留字

严格区分大小写

5，Python中的变量与数据类型

name='航空'
print(name)
print('标识',id(name))  #存储的内存地址
print('类型',type(name))  
print('值',name)

航空
标识 2351847402032
类型 <class 'str'>
值航空

数据类型：

整数类型：int 89

浮点类型：float 89.9999

布尔类型：bool True/False

字符串类型：str 航空只要加上单引号，双引号都是字符串类型

单引号和双引号只能在一行书写，二三引号或多引号能在多行书写

Python默认的位是十进制

6，数据类型转换

 #将int类型通过str类型转换位字符串类型
#str()是将其他类型转化位str类型的

#int()将其他类型转化为int类型
#将str类型转化为int类型，字符串要为数字串
#将float转化为int类型，截取整体部分
#将str转化为int类型，报错，因为字符串为小数串
#将str类型转化为为int类型时必须是数字串，并且还要为整数，非数字串也是不能转的

#float()将其他类型转化为float类型
#如果字符串是非数字串是不能转换
s1='126.1'
s2=23
s3='24'
ff=True

print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(s3),type(float(s3)))
print(float(ff),type(float(ff)))

126.1 <class 'float'>
23.0 <class 'float'>
24.0 <class 'float'>
1.0 <class 'float'>

7，Python中的注释

中文编码声明注释

#coding:utf-8 写在文档最前面的，标记你的文件的存储格式

8，输出

#input（）函数的使用   //input函数结果是一个str类型的
present=input('你想要什么？')
print(present,type(present))

你想要什么？想要吃饭
想要吃饭 <class 'str'>

#要求从键盘输入两个整数，计算两个整数的和
a=input('请输入一个数')
b=input('请输入另一个数')
print(a+b)

请输入一个数12
请输入另一个数10
1210 12和10都是str类型，因此这时候的加号是一个连接作用

9，Python中的运算符

（1）标准运算符（+，-，*，/，//(整除)

print(11/2)  #除法运算
print(11//2) #整除运算

5.5
5

#向下取整要取-3 一正一负

#都向下取整

print(9//-4) -3

print(-9//4) -3

（2）取余运算符（%）

print(11%2) #取余运算

（3）幂运算符（**）

#向下取整要取-3  一正一负
print(9//-4)    #都向下取整
print(-9//4)

#余数=被除数-除数*商
print(9%-4)   #9-（-4）*（-3）--》9-12=-3
print(-9%4)   #-9-4*（-3）--》-9+12=3

链式赋值

还支持解包赋值

a,b,c=20,30,40

print(a,b,c)

20 30 40

#交换方便交换两个数，不用中间变量

a,b=b,a

print(a,b)

30 20

（4）比较运算符

#比较运算符的结果是布尔类型
a,b=20,30
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
                           
'''
a=10
b=10
#a和b的值和标识都是相等的 ，其中标识就是地址
print(a==b)  #比较值
print(a is b) #比较地址

lst1=[11,22,33,44]
list2=[11,22,33,44]
print(lst1==list2)   
print(lst1 is list2)   值一样，但是地址不一样
print(lst1 is not list2)

True
False

（5）布尔运算符

逻辑关系

且 and

一个错全错

全队才对

a,b=1,2
print(a==1 and b==2) true 
print(a==1 and b<2)  false

或 or

一个对就对

全错才错

print(a==1 or b<2)  true
print(a!=1 or b==2) true

取反 not

对bool类型整体取反

f=True
f2=False 
print(not f)  false
print(not f2)  true

in与not in

s='hellow world'
print('w'in s)
print('k'in s)
print('w'not in s)
print('k'not in s)

（7）位运算符

将数据转换成二进制进行计算

位与&

对应数位都是1结果位数才为1，否者为0

位或|

对应数位都是0结果才为0，否则位1

左移运算符 <<

每移动一位乘以2

右移运算符 >>

向右移动一位相当于除以2

print(4>>2)  向右移动两位 结果为1

（8）运算符的优先级

先算算术运算符，再算位运算，然后在比较运算，最后为布尔运算

二、流程控制

任何简单或者复杂的算法都可以由顺序结构，选择结构和嵌套结构这三个基本结构组合而成

1，程序的组织结构

2，顺序结构

3，对象的布尔值

对象的布尔值，Python一切皆对象，所有的对象都有一个布尔值

一下对象的布尔值都为False，可以用bool()函数来判断

None

空字符列表

空列表

空元组

空字典

空集合

print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))  #空列表
print(bool(list()))  #空列表
print(bool(()))      #空元组
print(bool(tuple())) #空字元组
print(bool({})) #空字典
print(bool(dict()))#空字典
print(bool(set()))#空集合

以上对象全为False

4，分支结构

（1）单分支if结构

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

（2）双分支if..else结构

if 条件表达式：

条件执行体1

else

条件执行体2

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

（3）多分支 if ... else if ... else 结构

if 条件表达式1：

条件执行语句1

elif 条件表达式2：

条件执行语句2

elif条件表达式3：

条件执行语句3

【else：】可写可不写

#多分支结构
num=int(input('请输入一个分数'))

if 90<=num<=100:

还可以直接这样使用

if num>=90 and num<=100:
    print('A级')
elif num>=80 and num<=89:
    print('B级')
elif num>=70 and num<=79:
    print('C级')
elif num>=60 and num<=69:
    print("D级")
else:
    print('数据出错')

(4)if语句的嵌套

if条件表达式1：

if内层条件表达试：

内层条件执行体1

else：

内层条件执行体2

else：

条件执行体

例子：

# 嵌套if
''' 会员是>=200 8折 
   会员是>=100 9折
   非会员   >=200 9.5折
   不打折
'''
money=float(input('请输入购物总额：'))
answer=input('您是会员吗？')
if answer=='y':
    print('您是会员！')
    if money >= 200:
        print('会员打八折', money * 0.8)
    elif money >= 100:
        print('会员打9折', money * 0.9)
    else:
        print('会员不够打折优惠')
else:
    print('您不是会员')
    if money>=200:
        print('非会员打9.5折',money*0.95)
    else:
        print('非会员不够打折优惠',money)

（5）条件语句

#条件语句
num_a=int(input('请输入一个数字'))
num_b=int(input('请输入另一个数字'))
print('使用条件表达式进行比较')
print((num_a,'大于等于',num_b) if num_a>=num_b else (num_a,'小于等于',num_b))

if前面的为true else 后面的为false

还可以使用+进行连接，但是在连接之前必须都要转化为str类型的

print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于等于'+str(num_b))

5，pass空语句

语句什么都不做，只是一个占位符，用在语法需要语句的地方

什么时候使用：先搭建语法结构，但是还没想好代码怎么写的时候

那些语句一起使用：

if语句

#pass语句
answer=input('您是会员吗？')
if answer=='y':
 # 这个时候你还没想到是会员的时候代码怎么写就可以使用pass
     pass
else:
    # 这个时候你还没想到是非会员的时候代码怎么写就可以使用pass
    pass

if answer:

可以直接把表达式值当作条件去判断

6，循环语句

1，range（）函数的使用

用于生成一个整数序列

创建range（）的三个方式

（1）range（stop）创建一个（0，stop）之间的整数序列，步长为1

#第一种创建方式，只有一个参数，小括号中就只有一个数
r=range(10)  #默认从0开始，默认相差为1
print(r)     #range（0，9）
print(list(r))  #用于查看range对象中的整数序列 ，list是一个列表

range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）给了两个数，range（start，stop），创建一个（start，stop）之间的整数序列，步长为1

# 第二种创建方式，给了两个数，
r=range(1,10)  # 指定了起始值，从1开始到10结束，默认步长为1
print(list(r)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

（3）给了三个参数，range（start，stop，step），创建一个（start，stop，step）之间的整数序列，步长为step

# 第三种创建方式，给了三个数，
r=range(1,10,2)  # 指定了起始值，从1开始到10结束，默认步长为step 2
print(list(r))

[1, 3, 5, 7, 9]

2，in 与not in来判断整序列中是否存在指定的整数

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

False
True
False

range（）返回值是一个迭代器对象，range（）优点是range对象所占用的空间都是相同的，因为仅仅需要存储，start，stop，step三个值，只有当用到range对象时候，才会计算序列中的相关元素，如果不用他是不计算的

3，while循环

while 条件表达式：

条件执行语句（循环体）

while a<10:
    print(a)
    a=a+1

if 是判断一次条件，而while是判断多次

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

其中print('和为：',sum)要靠最左，不然会进入whil而进行循环

if not bool(num%2):与if num%2==0:是一样的操作

4，for-in循环

遍历问题

语法结构：

for 自定义的变量 in 可迭代对象：

循环体

for item in 'Python':
    print(item)

一次从Python中取出字母赋值给item，并输出，第一次取p，第二次取y

也就是Python是可迭代对象

列1；for item in range(10):
    print(item)

列2：#如果在循环体中不需要使用自定义变量，可将自定义变量写为‘_'
for _ in range(5):
    print('生而为人我很抱歉')

输出5次

生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉

列3：sum=0
for item in range(1,101):
    if not bool(item%2):
        sum=sum+item
print('偶数和为：',sum)

5，break，continue，else语句

break 用于结束循环结构，通常与分支结构if共同使用

列1：

'''
如果从键盘输入密码，最多三次，正确后就结束循环
'''
for item in range(3):    也可以使用这样代码：  while a<3:
    pwd=input('你的密码：')   #始终牢记input是字符串
    if pwd=='8888':
        break
    else:
        print('密码不正确')

continue语句用于结束当前循环，进入下一次循环，通常与分支结构if一起使用

不一样的是break是直接结束循环，而contiue是结束本次循环，进入下一次循环

列题：'''
要求输出1到50之间的所有5的倍数  ，只要余数为0或者5的都是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)

6，嵌套循环

例子：打印3行四列的矩形

'''输出一个三行四列的矩形'''
for i in range(1,4):  # 行表，执行三次，一次是一行
    for j in range(1,5):
        print('*',end='\t')  # 不含行输出
    print()

例子：打印九九乘法表

#输出九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
     print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环中的break和continue

只用于内层的循环

'''流程控制豫剧break与continue在二重循环中的使用'''
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            # break
            continue
        print(j,end='\t')
    print()

1   3   5   7   9
1   3   5   7   9
1   3   5   7   9
1   3   5   7   9
1   3   5   7   9

三、数据序列

字符串

1，字符串的驻留机制

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

'''字符串可以用单引号，双引号也可以使用多引号来定义'''
a='Python'
b="python"
c='''Python'''
#以上地址都是一样的

2，字符串的常用操作

'''字符串中大小写转换的方法'''
s='hello python'
a=s.upper()  #将其转换为大写，upper转换为大写之后会产生一个新的字符对象
b=s.lower()   #将其转换为小写，lower也是转换之后会产生一个新的字符对象
print(b==s)   #内容是相等的
print(b is s) #会报错，因为内容是相等的但是地址却不同
c=s.swapcase()  #是将s中大写的变成小写，小写的变成大写
d=s.title()     #将每个英文单词的第一个字母转换为大写，把剩余的单词都转换为小写

#字符串1的查询操作'''
s='hello,hello'
print(s.index('lo'))  #3
print(s.find('lo'))   #3
print(s.rindex('lo'))  #9
print(s.rfind('lo'))   #9

rindex和rfind都是逆向进行索引，并且，index在查询没有的时候会抛异常，而find或rfind在查询中没有的时候不会抛异常，而会输出-1

s='hello python'
print(s.center((20,'*')) )  #就是一共占用20个位置，该字符在中间，其中的两边用*来填充

****hello python****

print(s.ljust(20,'*') )   #左对齐

hello python********

print(s.rjust(20,'*'))    #右对齐，默认是空格
print(s.zfill(20)) #左对齐，只允许设置宽度剩余的全用来0来填充
print('-1908'.zfill(8))  #其中左对齐后，0的填充在负号的后面

lst=s.split()  #没有指定分隔符的时候，就会按照空格去区分
print(lst)
s1='hello|world|python'
print(s1.split(sep='|'))  #指定分隔符是’|‘
print(s1.split(sep='|',maxsplit=1)) #也就是自定义’|‘为分隔符，并且指定只分割’|‘前的一块，后面的放在一起
'''rsplit从右侧开始劈分'''
print(s1.rsplit())   #没有指定分隔符依旧使用空格进行区分
print(s1.rsplit('|')) #默认分隔符为‘|’
print(s1.rsplit(sep='|',maxsplit=1))  #就是默认用‘|’分割，并且只分割一个，从右边开始，其他的放在一起

print(s.isidentifier())
print('heool'.isidentifier())
'''判断是否是空白字符，isspace'''
print('\t'.isspace())
print(' '.isspace())
'''判断是否全部由字母组成'''
print('qbc'.isalpha())
print('张三'.isalpha())  #汉字也是由字母组成
'''判断是否由十进制的数字组成'''
print('919'.isdecimal())
print('123四'.isdecimal())#不是全部由十进制组成
'''是否全部由数字组成'''
print('1234'.isnumeric())
print('123四'.isnumeric())  #罗马数字，大写数学都是数字
'''是否全部由字母和数字组成'''
print('ABD11'.isalnum())
print('张三12'.isalnum())#汉字也是字母，！不是字母和数字

s='hello Python'
print(s.replace('Python','java'))   #用java替换掉了s中的Python
s1='hello,Python,Python，Python'
print(s1.replace('Python','java',2))#用java换Python换两次就够了，尽管有三个Python

lst=['hello','java','python'] #列表当中有三个字符串
print('|'.join(lst))  #用’|‘将列表中的三个字符串进行连接
print(' '.join(lst))  #用空格进行连接
t=('hello','java','python')
print(' '.join(t))  #将元组进行连接
print('*'.join('Python'))  #将Python看作字符串序列进行连接

hello java
hello,java,java，Python
hello|java|python
hello java python
hello java python
P*y*t*h*o*n

3，字符串的比较

print('apply'>'app')
print('apply'>'banan')
print(ord('a'),ord('b'))   #Ascii码的相互转换  ord    chr  
print(chr(98),chr(97))
'''==与is区别
  == 比较的是 value
  is 比较的是地址值id
'''
a=b='Python'
c='Python'
#a,b,c的地址都是一样的，因为字符串具有驻留机制

4，字符串的切片操作

'''字符串是不可变类型，不能进行增删改的操作，切片之后都将会产生一个新的对象'''
s='hello,Python'
print('------切片[start：end：step')
print(s[::2])#默认从0开始，没有写结束，默认到字符串的最后一个元素结束
print(s[::-1])#默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数，-1最后一个元素
s1=s[:5]#不写起始位置，将会从0开始，默认步长为1
s2=s[6:]#不写终点位置，一般会切到最后
s3='!'
newstr=s1+s3+s2
print(s1)
print(s2)
print(newstr)
print('------------')
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))  #切片的地址都是不一样的

5，格式化字符串

'''%占位符'''
name='张三'
age=20
print('我是%s，今年%d岁'%(name,age))

我是张三，今年20岁

'''%占位符'''
name='张三'
age=20
print('我是%s，今年%d岁'%(name,age))
'''{}占位符'''
print('我叫{0},今年{1}岁'.format(name,age))
'''f-string'''
print(f'我叫{name},今年{age}岁')  #只需前面加上f
'''精度'''
print('%10d'%99)   #%10d指的是宽度
print('%.3f' % 3.1415926)  #%.3f指的是保留三位小数
print('%10.3f'%3.1415926)    #%10.3f表示的是，10是占位总宽度为10，.3是保留多少小数
print('{0:.3}'.format(3.1415926))  #.3表示的是一共3位数。.3f表示的是3位小数
print('{0:10.3f}'.format(3.1415926))#其中{}中的0也是可以略的，同时设置宽度和精度

6，字符串的编码转换

s='天涯共此时'
'''编码'''
print(s.encode(encoding='GBK'))  #在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))#在UTF-8这种编码格式中，一个中文占三个字节
'''解码'''
#byte代表的就是一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')  #编码
print(byte.decode(encoding='GBK')) #解码   编码和解码要一样 否则不能解码

7，字符串总结

字典

1，什么是字典

字典是Python内置的数据结构之一，与列表一样是一个可变序列（可以增删改操作），以键值对的方式存储数据，字典是一个无序的序列。用{ }来定义，字典是一对对来存储的“

”：“之前的叫做键，‘：’之后的叫做值，存储在字典中要通过hash（key）函数来进行的，所以是无序的，因此键的不可变序列，字符串也是不可变序列

2，字典的原理

3，字典的创建与删除

# 最常用的方式：使用使用花括号
score={'张三':100,'李四':89,'王五':20}
print(score)
print(type(score))

{'张三': 100, '李四': 89, '王五': 20}
<class 'dict'>

# 使用内置的函数dict()  左边是键右边是值
student=dict(name='jack',age=20)
print(student)

{'name': 'jack', 'age': 20}

'''可以创建空字典'''
d={}
print(d)

字典中元素的获取

'''第一种获取字典元素的方式 使用【】'''
print(score['张三'])  #如果查找的键不存在会报错，而get（）不会报错

'''使用get（）方法'''
print(score.get('张三'))
print(score.get('麻七'),200)  #200是早查找’麻七‘不存在对应值的一个默认值

key的判断in not in

score={'张三':100,'李四':89,'王五':20}
print('张三'in score)
print('张三'not in score)

True
False

字典的删除 del scores【'张三’】

del score['张三']
print(score)

删除一对

字典元素的新增 scor【‘JACK’】=90

score.clear()  #情况字典的所有元素
score['陈六']=80  #添加键值对
score['陈六']=100  #修改键值对

4，字典的查询操作

获取字典的视图操作三个方法

key（）获取字典中所有的key

value（）获取字典的所有值

items（）获取字典中所有的key，value对

#获取所有的键
score={'张三':100,'李四':89,'王五':20}
keys=score.keys()
print(keys)
print(type(keys))
print(list(keys))  #将所有键组成的视图转化为列表
# 获取所有的值
values=score.values()
print(values)
print(type(values))
print(list(values))   #将所有值组成的视图转化为列表
# 获取所有的键值对
items=score.items()
print(items)  #元组
print(type(items))
print(list(items)) #将所有键值对组成的视图转化为列表，转换之后的列表是由元组组成的

5，字典元素的增，删，改操作

key的判断in not in

score={'张三':100,'李四':89,'王五':20}
print('张三'in score)
print('张三'not in score)

True
False

字典的删除 del scores【'张三’】

del score['张三']
print(score)

删除一对

字典元素的新增 scor【‘JACK’】=90

score.clear()  #情况字典的所有元素
score['陈六']=80  #添加键值对
score['陈六']=100  #修改键值对

字典元素的遍历

for item in scores：

print（item）

获取的实际上是字典当中的键

score={'张三':100,'李四':89,'王五':20}
for item in score:
    print(item,score[item],score.get(item))   #前一个是键，后两个获取的是键对应的值

张三 100 100
李四 89 89
王五 20 20

6，字典的推导式

字典的一些特点：

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

字典中的元素是无序的

字典的key必须是不可变对象

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

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

列表

变量只能存储一个元素，而列表是以一个大容器，可以存储N多个元素，程序可以方便的对这些数据进行整体操作，相当于其他语言的数组。

a=10  # 变量存储的是一个对象的引用
lst=['hello','world','98']
print(id(lst))
print(type(lst))
print(lst)

1967148470336
<class 'list'>
['hello', 'world', '98']

1，列表的创建与删除

'''创建列表的第一种方式'''
lst=['hello','world','98']
'''创建列表的第二次方式'''
lst2=list(['hello','world','98'])

列表的特点：

列表映射一个列表的数据

列表里面可以重复数据

任意数据类型可以混合

根据需要动态分配和回收内村

2，列表的查询操作

lst=['hello','world','98','hello']
print(lst.index('hello'))

如果列表有相同元素，只返回列表中第一个元素的索引

指定范围内查找索引

# print(lst.index('hello',1,3))  #意思是在列表中从索引为1的元素到索引为3的元素进行查找hello，不包括索引为3的
print(lst.index('hello',1,4))  #意思是在列表中从索引为1的元素到索引为3的元素进行查找hello

获取列表当中的单个元素

# 希望获取索引为2的元素
print(lst[2])
#获取索引为-3的元素
print(lst[-3])  #从后往前数  范围为-N到-1
#获取索引为10的位置
print([lst[10]])   # 超出范围会报错

str = "abcdefa"
print(str.find("a")) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果
print(str.find("a",1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果6
print(str.find("7"))# 查找不到返回-1

获取列表当中的多个元素

列表名[start:stop:step]

#开始为1，步长为6，每步为1
print(lst[1:6:1])  #不包含索引为6
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段:',id(lst2))
print(lst[1:6])   # 默认步长为1
print(lst[1:6:])  # 也是默认步长为1
print(lst[1:6:2]) 
print(lst[:6:2])  #默认从0开始
print(lst[1::2])  #长度默认为结束

print('-----步长为负数的情况-----')
print(lst[::-1])  #默认步长为1，且逆序输出
print(lst[7::-1]) #和上输出一样
print(lst[6:0:-1])

print('p' in 'Python')
print('k' not in 'Python')
# 同样的列表中也可以使用in not in
lst=[10,20,'Python','hello']
print(10 not in lst)
print(10 in lst)
# 也可以遍历列表当中的元素
for item in lst:
    print(item)

False
True
10
20
Python
hello

3，列表元素的增，删，改操作

列表增加：

'''向列表的末尾添加一个元素'''
lst=[10,20,30]
lst.append(100)  #代表在列表的末尾添加一个元素
print('添加元素之后的列表',lst)   #并且标识没有修改
# 在列表的末尾至少添加一个元素
lst2=['hello ','world']
lst.append(lst2)  #将列表的元素做为一个元素添加到列表的后面
print(lst)
lst.extend(lst2)  #是将列表后面扩展了，是将lst2中的每一个元素都当做一个元素添加到末尾多个元素
print(lst)
# 在任意位置上添加元素
lst.insert(1,90)   #在索引为2的位置上添加元素
print(lst)
# 在任意位置上添加n多元素
lst3=['True','false']
lst[1:]=lst3  #切片，没有写结束在哪里，然后把元素切掉后将lst3的元素挨个添加后面

列表删除

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

#pop（）根据索引移除元素
lst.pop(1)  # 就是将索引为1的元素移除了，如果不指定参数，将删除列表中最后一个元素

print('-----切片-删除至少一个元素，将产生一个新的列表对象')
new_list=lst[1:3]  #就是说只保留原列表中的第一位到第2位的元素
'''不产生新的列表对象而是删除原列表中的内容'''
lst[1:3]=[]  #就是用空列表将中间的替代
'''清楚列表中的所有元素'''
lst.clear()
'''del语句将列表对象删除'''
del lst  #直接将列表删除

修改列表元素

'''一次修改一个值'''
lst[2]=100  #修改固定位置索引上的值

'''一次修改一个值'''
lst[2]=100  #修改固定位置索引上的值

''' 修改列表当中的多个值'''
lst[1:3]=[300,400,500]

4，列表元素的排序

sort（）方法进行排序

lst=[20,30,12,5,60]
print('排序前的列表',lst)
#开始排序，调用列表中的sort方法，默认升序排序
lst.sort()
print('排序之后的列表',lst)  #是在原列表上进行的排序
# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  #就是降序排序的判断
lst.sort(reverse=False)  #就是降序排序，一般年没有指定就是默认降序·
sorted（）进行排序
'''使用内置函数进行排序，但是会产生一个新的列表对象'''
print('----------使用内置函数sorted（）进行排序，将产生一个新的列表对象------')
new_lst=sorted(lst)  #原列表没有变化，而是产生一个新的列表对象
#指定关键字，来实现降序排序
deec_lst=sorted(reverse=True)  #内置函数的降序排序

5，列表的推导式

【i*i for i in range(1,10】

lst=[i for i in range(1,10)]  #产生一道九的序列并
print(lst)
lst=[i*i for i in range(1,10)]  #前面i称为表示列表元素的表达式
print(lst)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

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

可迭代对象就是指可以进行变量的对象

items=['张三','王五','李四']
prices=[20,30,40]
 d={item:price    for item,price in zip(items,prices) }

元组

1，什么是元组

元组是一个不可变序列，因此没有增删改操作，字符串也是不可变序列

列表，字典是可变序列，因为可以增删改，并且地址也没有发生更改

2，元组的创建方式

t=（‘Python’，‘hello’，90）外观上和列表相差括号，列表是由方括号表示的【】

''第一种，使用（）'''
t=('Python','world',98)
#其中第一种的创建方式，括号可以不用写，如果一个元组只有一个元素时候要使用,和小括号
t2='Python','world',98
t3=('python',)   #一个元素的元组，逗号和括号不能省

'''第二种创建方式，使用内置的函数tuple'''
t1=tuple(('typhon','world',90))

# 空元组
t4=()
t5=tuple()
# 空列表的创建方式
lst=[]
lst1=list()
#空字典的创建方式
d={}
d2=dict()

为什么要将元组设计成不可变序列

在多任务环境下，同时操作对象不需要枷锁

因此，在程序中尽量使用不可变序列

元组中存储的是对象的引用，如果元组中对象是不可变对象，则不能在引用其他对象，如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t=(10,[20,30],90)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))   #这为列表
print(t[2],type(t[2]),id(t[2]))
'''将t0修改为100'''
t[0]=100  #错误的，元组是不能修改的，但是由于t[2]为列表，可以修改
t[1].append(100)  #这是可以的，并且id是不变的

3，元组的遍历

t=('python','world',98)
'''第一种获取元组的方式，使用索引'''
print(t[1])  #可能会超出索引

'''遍历元组'''
for item in t:
    print(item)   #其中item就是元组的索引长度

4，什么是集合

集合是可变的类型的序列，集合也是{ } 和字典表达方式一样，但是集合不成对出现的，是没有value的字典，也是hash函数进行的

s={ }

5，集合的增删改查操作

集合元素的判断操作

in或not in

集合元素的新增操作

调用daa()方法，一次添中一个元素

调用update（）方法，至少添中一个元素

集合元素的删除操作

调用remove（)操作，一次删除一个指定元素，如果指定元素不存在就抛出keyerro

调用discard(）方法，一次删除一个指定元素，如果指定元素不存在不抛出异常

调用pop（）方法，一次删除一个任意元素

调用clear（）方法，清空集合

'''集合元素的判断操作'''
s={10,20,30,40}
print(10 in s)
print(100 not in s)  #是bool类型

'''集合元素的新增操作'''
s.add(90)  #添加一个用add
print(s)
s.update({200,300,400})  #添加一个集合
print(s)
s.update([100,20,30])  #update既可以放元组，也可以放列表
s.update((11,1,12))  #update集合添加多个也可以用列表

'''集合元素的删除操作'''
s.remove(100)  #使用remove删除的时候，不存在的时候会抛出异常
s.discard(500)  #使用discard删除的时候，不抛出异常
s.pop()    #pop不能添加参数，只能随机删除一个
s.clear() #是清空集合中的元素

6，集合的关系和集合的生成式

两个集合是否相等

可以用==或 !=来判断

一个集合是否是另一个集合的子集

可以调用issubset进行判断

一个集合是否是另一个集合的超集

可以调用issuperset进行判断超集合也就是这个集合包含另一个集合

两个集合是否没有交集

可以调用方法isdisjoint进行判断

'''两个集合是否相等,元素相同就相等'''
s={10,20,30,40}
s1={10,20,30}
s2={20,30,40,10,50,13}
print(s==s2)  
print(s!=s2)

'''一个集合是否是另一个集合的子集'''
print(s.issubset(s1))  #s是否是s1的子集
print(s1.issubset(s2))  #

'''一个集合是否是另一个集合的超集'''
print(s.issuperset(s2))  #正好与子集反过来

'''两个集合是否有交集'''
print(s1.isdisjoint(s2))  #若两个子集有交集就是false,没有交集就是true

'''交集操作'''
s1={10,20,30,40,50}
s2={10,20,30}
print(s1.intersection(s2))
print(s1 & s2  ) #intersection 与&是等价的，都是交集操作

'''并集操作'''
print(s1.union(s2))
print(s1|s2)  #union是和| 等价，并集操作

'''差集操作'''
print(s1.difference(s2)) #也就是用s1-s1和s2共同有的部分
print(s1-s2)   #- 和上面的difference是一样的都是差集操作

'''对称差集'''
print(s1.symmetric_difference(s2))   #就是去掉二者都有的部分，然后将两者剩余的整合在一起
print(s1^s2)  #^和symmetric_difference是一样的

集合的生成式

#列表生成式
lst=[i*i for i in range(8)]   #大意就是生成0到5之间的整数，然后再将这些整数乘起来（i*i）,然后将其放入列表lst当中
print(lst)
#集合生成式
lst={i*i for i in range(8)}  #其中集合的数据是错乱的
print(lst)

7，列表，字典，元组，集合总结

四、函数

1，函数的创建和调用

def calc(a,b):
    c=a+b
    return c

result=calc(10,20)
print(result)

2，函数的参数传递

def calc(a,b):  #a,b是形式参数
    c=a+b
    return c

result=calc(10,20)  #10,20是实参，实参的位置是函数的调用处
print(result)

#关键字实参
res=calc(b=10,a=20)  #赋值给名称相同的参数  =号左侧的变量名称就称为关键参数

def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(100)
    print('arg1=:',arg1)
    print('arg2=',arg2)

n1=11
n2=[22,33,44]
fun(n1,n2)  #位置传参，arg1,arg2是函数定义的形参，n1,n2是函数调用的实参，实参和形参名字可以不相同
print('n1=',n1)
print('n2=',n2)
#其中n1的值是不变的
'''在函数调用的过程中，进行的参数的传递'''
'''如果是不可变对象，在函数体内的修改不会影响实参的值
    如果是可变对象，在函数体内的修改会影响到实参的值'''

3，函数的返回值

def fun(num):
     odd=[] #存奇数
     even=[]#存偶数
     for i in num:
         if i%2:
             odd.append(i)
         else:
             even.append(i)
     return odd,even


 lst=[10,29,30,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
   （1）如果函数没有返回值【函数执行完毕后，不需要给调用处提供数据] return 可以省略不写
    (2)函数的返回值，如果是一个，直接返回类型
    （3）函数的返回值，如果是多个，返回值的结果为元组
'''
#（1）
def fun1():
    print('hello')
fun1()
#(2)
def fun2():
    return 'hello'
res=fun2()
print(res)
#（3） 多个返回值返回元组
def fun3():
    return  'hello','world'
print(fun3())

4，函数的参数定义

'''个数可变的位置参数'''  #只能定义一个
def fun(*arges):   #*是不知道参数的个数,*是数组，用*定义一个可变的位置形参，结果为一个元组
    print(arges)
    print(arges[0])
fun(10)
fun(10,20,30)
'''个数可变的关键字形参'''
def fun1(**arge):  #arge是一个字典   也只能定义一个
    print(arge)

fun1(a=10)
fun1(a=20,b=30,c=40)
def fun2(*arges,**arges2):
//def fun3(**agre1,*agre):  #报错
    '''在一个函数的定义之中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参要放在个数可变的关键字形参之前'''

5，变量的作用域

def fun(a,b):
    c=a+b   # c就是局部变量，而a和b是函数的形参，相当于局部变量
    print(c)
name='刘老师'
def fun1():
    print(name)
fun1()  #因为name的全局变量

def fun2():
    global age
    age=20
    print(age)
fun2()
print(age)  #函数内部定义的变量，局部变量，但是如果局部变量使用global声明，这个变量实际上就成为了全局变量

6，递归函数

7，函数总结

def fun(a,b,c):
lst=[11,12,13]
fun(*lst)  #不能使用fun(lst)  否则会认为只传了一个参数，只能加个*将列表中的每一个元素都转换为位置实参传入
fun(a=110,b=100,c=200)  #函数的调用，所以是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic) #在函数的调用时，将字典的键值对都转换为关键字实参传入

def fun(*arge): #个数可变的位置形参
    print(arge)

def fun1(**args): #个数可变的关键字形参
    print(args)
fun(10,20,30,40)   #里面个数想写多少就写多少
fun1(a=10,b=11,c=12)   #传多少都可以

def fun4(a,b,*,c,d):   #在c和d之前加个*说明c和d只能使用关键字传参,从这个*之后的只能采用关键字实参传递
    pass
fun4(19,20,c=10,d=10)  
'''函数定义的形参的训序问题'''
def fun5(a,b,*,c,d,**agre):
    pass
def fun6(*args,**arge):
    pass
def fun7(a,b=10,*args,**arge):
    pass

#斐波那契数列
def fac1(n):
    if n==1:
        return 1
    elif n==2:
        return 2
    else:
        return fac1(n-1)+fac1(n-2)
#输出这个数列前6位上的数字
for i in range(1,7):
    print(fac1(i))

lambda表达式

五，Bug的问题

Bug的由来及分类

age=input('请输入你的年龄：')
print(type(age))   #问题，通过input输入的是字符串，尽管是数字也是字符串，不能直接那他来进行与数字比较
if age>=18:
    print('你应该成年了')
    i=0
    while i<10:   #一定要给i赋值，并且还要确定不能进入死循环
        print(i)

要用==个等号

常见的异常类型

异常处理机制

PyCharm的调用模式

六、文件操作

编码格式介绍

不同的编码方式决定了占用磁盘空间的大小

文件读写原理

先进先出的方式

file=open('a.txt','r')   #读完之后赋给file变量
print(file.readlines())   #进行文件的都写操作  #readlines读取后是将其放到一个列表中会读取文件中的所有内容
file.close()  #读完进行关闭

file=open('b.txt','w')   #进行写操作，若文件没有则进行创建文件
file.write('python')     #若文件已经有了，则再写进去会将文件中的内容进行替换
file.close()

文件对象的常用方法

file=open('a.txt','r')
print(file.read())  #全部读完
print(file.read(2))  #read(2)代表读取两个字符
print(file.readline()) #readline只读取一行
print(file.readlines())  #读取一行作为列表
file=open('a.txt','a')  #a是追加，w是覆盖
file=open('a.txt','w')
#不及可以将字符串写进内容，还可以将列表写进去
lst=['java','go','pyhton']
file.writelines(lst)  #将列表写进文件中

with语句（上下文管理器）

with open('a.text','r') as file:
    print(file.read())   无论是否产都会调用关闭这个函数语句
    #此时不必写关闭代码，因为with语句之后就会自动关闭资源了

建议使用with语句来进行读取文件

with open('logo.webp','rb') as scr_file:
    with open('copy.logo','wb') as target_file:
        target_file.write(scr_file.read())   #变进行读，变写操作

目录操作

七、面向对象和面向过程

两大编程思想

类和对象的创建

类的创建
class Student:   #Student 为类的名称，也就是类名，由一个或多个单词组成，每个单词的首字母大写，其余小写
   native_pace='河南'  #直接写在类里的变量称为类属性
   
   def __init__(self,name,age):
       self.name=name   #self.name称为实例属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
       self.age=age
   def eat(self):     #类里面定义的函数称为实例方法，而不叫函数了
       print('就知道吃')
       
   #静态方法
   @staticmethod
   def  method():
       print('使用staticmethod进行修饰，所以是静态方法')

   #类方法
   @classmethod
   def cm(cls):
       print('类方法，因为使用了classmethod进行修饰')

#Python 一切皆对象 Student 是对象吗，内存由开空间吗
print(id(Student)) #1743266496832
print(type(Student)) #<class 'type'>
print(Student) #<class '__main__.Student'>

对象的创建

#创建Student类的对象  这个为实例对象，就是给类赋具体值的
stu=Student('张三',20)
#创建完对象后，就可以使用类中的所有方法和调用
stu.eat()    
#还可以以下进行调用和stu.eat()   一样
Student.eat(stu)  #都是调用Student中的方法
print(stu.name)
print(stu.age)

类对象与类属性

类属性

#类属性的使用方式
print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)   #结果都为河南
Student.native_pace='天津'
print(stu1.native_pace)
print(stu2.native_pace) #结果都变为天津了

#类方法是使用方式
Student.cm()  #这就是类方法的使用方式

类方法与静态方法

静态方法

#静态方法的使用
Student.method()  #静态方法也是直接进行调用

动态绑定属性和方法

动态绑定属性

class Student:
    def __init__(self,name,age):
        self.name=name  #将局部变量赋给实例变量
        self.age=age
    def eat(self):
        print(self.name+'在吃饭')

stu1=Student('张三',20)
stu2=Student('李四',10)

#若想给李四单独增加一个属性，让其为性别，这时候就是需要动态的绑定属性了
print('---------为stu2动态绑定一个性别-------')
stu2.gender='女'   #这就是为stu2单独绑定的性别属性
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender)

动态绑定方法

#动态绑定方法
stu2.eat()
stu1.eat()
def show():  #定义在类之外的称为函数
    print('类之外的为函数')
stu1.show=show  #动态绑定方法
stu1.show()

面向对象

1,封装

提高程序的安全性

class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('车已启动')
类是对属性和方法的封装
car=Car('奔驰')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
           self.name=name
           self.__age=age  #年龄不希望在类的外部进行使用，因此前面加了两个__
    def show(self):
        print(self.name,self.age)
Stu=Student('张三',20)
#在类的外部进行使用name和age
print(Stu.name)
print(Stu.__age)  #这个是不能被拿出来
#

2，继承

提高代码的复用性

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)  #super函数是用于调用父类的一个方法
        self.stu_no=stu_no
class Teach(Person,Student):  #里面可以多继承
    def __init__(self,name,age,teacheryear):
        super.__init__(name,age)
        self.teacheryear=teacheryear

stu=Student('李四',20)
teacher=Teach('张三',30)

stu.info()
teacher.info()
#info()都是从父类中继承出来的

3，方法重写

4，object类

5,多态

提高程序的可扩展性和可维护性

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):  #obj是传入对象的意思
    obj.eat()
#开始调用函数
fun(Cat())   #继承类，进行方法重写
fun(Animal())
fun(Dog())
#Person不存在继承关系
fun(Person())
#但是Person有自己的方法所有会调用自己的方法

6,特殊方法和特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建C类的对象
x=C('Jack',20)  #x是c类的一个实例对象
print(x.__dict__)  #绑定的是实例对象的属性字典
print(C.__dict__)   #类属性和方法的字典

print(x.__class__) #输出对象所属的类
print(C.__bases__)  #输出的是C类的父类的元素
print(C.__base__) #输出的是和他最近的一个父类
print(C.__mro__) #查看的是一个类的层次结构
print(A.__subclasses__())  #子类的一个列表

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return  self.name+other.name
    def __len__(self):   #必修要在类中写len方法，才能进行实例的相加
        return len(self.name)
stu1=Student('张三')
stu2=Student('李四')
print(stu1+stu2)   #由于在类中写了__add__这个方法，所以就可以进行相加了  两个对象相加

lst=[11,22,33,44]
print(len(lst))
print(lst.__len__())  #一样的和上面计算列表长度
print(len(stu1))

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(cpu2,id(cpu1))
print(cpu1,id(cpu2))
#实际上是一个对象放到了两个变量中去

#(2)类的浅拷贝，python一般都是指浅拷贝
print('-----------------')
disk=Disk()  #创建一个硬盘类的对象 
computer=Computer(cpu1,disk) #创建一个计算机类的对象

#开始浅拷贝
import copy
computer2=copy.copy(computer)  #浅拷贝只拷贝原对象，子对象不拷贝，就是cpu和disk
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

#深拷贝
computer3=copy.deepcopy(computer)  #会将其子对象也进行拷贝
print(computer,computer.cpu,computer.disk)
print(computer3,computer3,computer3.cpu,computer3.disk)

八、模块、包、异常

什么是模块

def fun():   #模块包含函数
    pass
def fun2():
    pass
class Student:  #模块包含类
    native_place='吉林'   #类中包含类属性
    def cat(self,name,age):       #类中包含实例方法
        self.name=name
        self.age=age       #name。age是实例属性
    @classmethod
    def cm(cls):        #类方法
        pass
    @staticmethod        #静态方法
    def sm():
        pass

自定义模块

import math  #导入math模块
print(id(math))
print(math.pi)
print('--------查看函数有那些可以调用-----')
print(dir(math))   #dir查看模块中都有那些方法
from math import  pi  #这个只是导入了math中的pi
print(pi)

以主程序形式执行

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

if __name__=='__main__':   #不写这个的时候，否则到时候带调用该模块时候，会执行不该运行的东西
   print(add(10,20))  #只有当运行自身模块时候才会进行运算。

Python中的包

包的导入

import papagel.moudel1 as a  #a为其别名
#print(papagel.moudel1.a)
print(a.a)
import 学习包
#在导入含有包的模块时注意事项
import  papagel
import  demo1
#使用import进行导入时只能后面跟包名和模块名
#使用from ....import可以导入包，模块，函数，变量

第三方模块的安装及使用

import sys #导入Python内置的模块  与Python解释器及其环境相关的标准库
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
import time
#导入与时间有关的time
print(time.time())
print(time.localtime(time.time()))
import urllib.request
#导入与爬虫有关的

OS模块应用

import  os  #os是操作系统上的模块
os.system('notepad.exe')   #打开电脑的记事本
os.system('calc.exe')       #打开计算器
#还可以直接调用可执行文件
os.startfile('C:\\progaram Files\\Tencent\\QQ\\bin\\qq.exe')  #打开可运行的QQ程序

import  os  #os是操作系统上的模块
print(os.getcwd())   #查询运行的目录路径
#os.listdir('..//chap15')  #..//是退一级目录，n把该一级的目录的文件全部输出
#os.mkdir('newdir2')  #创建一个目录
os.makedirs('A/B/C') #创建一个多级目录  A里有个B,B里有个C
os.rmdir(path)  #删除一个目录
os.removedirs(path)  #删除多级目录
os.chdir('E:\\path')   #将path设置为当前目录

import  os.path
os.path.abspath(path)  #输出绝对路径 绝对路径就是获取路径的全部
os.path.exists(path)   #判断目录是否纯在
os.path.join(path2,path1) #路径进行拼接

import  os.path
os.path.abspath(path)  #输出绝对路径 绝对路径就是获取路径的全部
os.path.exists(path)   #判断目录是否纯在
os.path.join(path2,path1) #路径进行拼接
os.path.split('path')  #分离路径,将目录与文件进行拆分
os.path.splitext('path')  #拆分文件与后追名
print(os.path.basename('path'))  #提取一个文件的名字

#案例1

#列出指定目录下的所有的py文件
import os
path=os.getcwd()  #获取当前目录
lst=os.listdir(path)   #获取目录所有文件
for filename in lst:
    if filename.endswith('.py'):  #在所有文件的列表中，如果文件是.py结尾的就进行打印输出
        print(filename)         #进行输出

总结

学生信息管理系统

1，需求分析

2，系统设计

3，系统开发必备

4，主函数设计

5，学生信息维护模块设计

6，查询/统计模块设计

7，排序模块设计

8，项目打包

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

空中梦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python学习

提示：以下是本篇文章正文内容，下面案例可供参考字典是Python内置的数据结构之一，与列表一样是一个可变序列（可以增删改操作），以键值对的方式存储数据，字典是一个无序的序列。用{ }来定义，字典是一对对来存储的“”：“之前的叫做键，‘：’之后的叫做值，存储在字典中要通过hash（key）函数来进行的，所以是无序的，因此键的不可变序列，字符串也是不可变序列元组是一个不可变序列，因此没有增删改操作，字符串也是不可变序列列表，字典是可变序列，因为可以增删改，并且地址也没有发生更改。
复制链接

扫一扫