菜鸡的Python学习笔记（持续更新）

1.Print的使用

#输出数字

print(520)
print(98.5)

#输出字符串

print("Helloworld")
print('Helloworld')

#输出表达式

a = 3 
b = 5
print(a + b)
print(3 > 5)

#将数据输出到文件(python用正斜杠分隔文件路径）
#注意：所输出的盘符要存在
#使用file = …的形式

fp = open('D:/text.txt' , 'a+')
print("Helloworld",file = fp)
fp.close()

#用“,”隔开输入在一行里

print("Hello world","abc")

#print输出不换行
#python的print默认输出回车，改了就好

print(xxxx,end = "")

2.转义字符和原字符

转义字符

print("Hello\nWorld") #\n -> newline
print("你好你好\tWorld") #\t -> tab （与前面字符补足八个字节位，若前面子符正好八个字节位输出八个）
print("ssa\bs") #\b退一个格

print('他说：\'你好\' ')
print("c:\\baidu\\baike")
#反斜杠转义

#原字符，不希望转义字符起作用，在前面加r
#最后一个字符不能是反斜线,
print(r"c:\baidu\baike")
#但可以是双斜线
print(r"c:\baidu\baike\\")
#想输出但斜线可以
print(r"c:\baidu\baike"'\\')

3.二进制与字符编码

两个重要BIF

print(chr(25104))  #chr() 将编码转化为字符
print(ord("成")) #ord(字符) 输出字符的十进制ascii值

4.python 中的标识符与保留字

import keyword
print(keyword.kwlist)
#输出python所有保留字

#变量、函数、类、模块和其他对象的名字就叫标识符
#变量不能以数字开头，不能使用保留字，严格区分大小写

5.变量的定义与使用

a = '玛丽亚'
b = 3
c = "hello world"

print(id(a)) #获取变量地址
print(type(b)) #获取变量类型
print(c) #获取变量值

#变量名相当于指向一个地址的指针，当一个变量再次被赋值，他会指向新的地址
#之前指向的地址会变成垃圾地址，

c = 3
c = "sss"
print(c)

6.python数据类型

#整形数据
a = 85 #十进制
aa = 0b1010101 #0b开头2进制
aaa = 0o125 #0o开头8进制
aaaa = 0x55 #0x开头16进制

print(a)
print(aa)
print(aaa)
print(aaaa)
print(hex(a))

#bin(a)实现二进制输出
#oct(a)实现八进制输出
#hex(a)实现十六进制输出

#浮点型数据

b = 3.14159
print(b , type(b)) 
#浮点数存储小数的位数不确定
n1 = 1.1
n2 = 2.2
print(n1 + n2)
#解决方案 导入模块decimal
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2') )

#布尔型数据

c = False #数字0
d = True #数字1
#bool类型可以当作int计算
print(True + 1)

print(c)
print(d)

#字符串类型
#可以用单引号 双引号 三引号
#单双引号必须输入在一行
#三引号括住的可以输入多行字符串

e = "人生苦短，我用python"
f = '我永远喜欢香风智乃和泉纱雾石原里美铃木爱理桥本环奈'
g = '''
本是同根生
草泥马戈壁
'''

print(e)
print(f)
print(g)

7.python数据类型转换和字符串拼接

数据类型转换

#转换成为整数

a = '3'
print(int(a))
#只有整数类字符可以转化为整数
b = 4.5
print(int(b))
c = -3.7
print(int(c))
#浮点数转换为整数直接去掉小数部分

#转换成浮点数

d = '3.5'
print(float(d))
e = '3'
print(float(e))

#字符只要是数字就可以转化为浮点数
#整数转换为浮点数会在末尾加.0

#转化为字符
d = 3.5
print(str(d))

字符串之间的连接

#字符串之间可以用 + 连接

a = "sss"
b = "xxxx"
c = "asd"
print(a + b + c)
name = "香风智乃"
print(name + "永远喜欢我")
print("我今年" + str(3) + "岁" + "我喝旺仔牛奶已经"+str(8)+"年了")

"""
三引号之间的
东西为多行注释
"""

8.input函数的应用

a = input("请输入 ")
print(a)
#input("提示语") 可供赋值给一个变量

#input输入的是 字符型

a = int(input())
b = int(input())
print(a + b)

9.运算符

+ - * /

print(1 + 1)
print(2 - 3)
print(3 * 5)
print(8 / 3)

整除(向下取整) //

print(11 // 2)
print(11 // -2)

取余运算 %

 print(12345 % 2)

乘方运算 **

print(2 ** 3)

赋值运算符 =（从右往左执行）

a = 3 + 4 #a = 7
print(a)

链式赋值

b = c = d = 30 #实际b,c,d公用同一地址
print(b , c , d)

参数赋值

e = 50
e *= 2
print(e)

解包赋值

a1 , b1 , c1 = 20,30,40
print(a1 , b1 , c1)

#从而交换两数的值

aa = 1 
bb = 2
aa,bb = bb ,aa
print(aa , bb)

##比较运算符

a = 10
b = 10
print(a > b) #比较结果为bool类型
print(b >= a) 
print(a == b) #一个=为赋值运算符，两个=为比较
print(a is b) # is/is not比较两个变量地址是否相同
#在python中一般值相同的用同一个内存地址
#不适用于元组，字符串
print(a != b)

bool 运算符

#按位运算
#在每个二进制位
'''

and 判断条件时候返回真假，全真为真

or 一个真则为真(如果前面为真直接略过后面返回真）

not 非零数直接返回false

in/not in
返回一个数是否在元组中
返回字串是否在字符串里
'''

位运算符

'''
与运算
&
1 & 0 = 0
1 & 1 = 1
0 & 0 = 0
13 & 11 = 9
1101 & 1011 = 1001
'''
print(13 & 11)

'''
或运算
1 | 1 = 1
1 | 0 = 1
0 | 0 = 0

亦或运算
1 ^ 1 = 0
0 ^ 0 = 0
1 ^ 0 = 1

取反运算
0变1 ， 1变0
~9 = 6

左移 << 二进制全部左移
100 << 1 = 1000
1001 << 1 = 10010

右移 >> 二进制全部右移

100 >> 1 = 10
101 >> 1 = 10

'''

运算符优先级

#算术 > 位运算 > 比较 > 逻辑 > 赋值

10.对象的bool值

#python中一切都是对象
#每一个对象都有一个bool值
#用bool()获取

以下对象bool值为False

print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool("")) #长度为0的字符串
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({
     })) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合

#其他对象的bool值均为true

11.分支结构

用法 if 条件表达式 :

单分支结构

print("输入一个数，如果是奇数就输出")
s = int(input())
if s % 2 != 0:
    print(s)

双分支结构

money = 1000
s = int(input('请输入取款金额：'))
if s > 1000 :
    print("钱不够，爬")
else:
    print("彳亍")

多分支结构

print("你选择几号女朋友")
s = int(input())
if s == 1:
    print("香风智乃")
elif s == 2:
    print("和泉纱雾")
elif s == 3:
    print("凤姐")
else:
    print("你没有女朋友")

分支嵌套

s = int(input())
if s > 1:
    if s == 2:
        print("H")
    elif s == 3:
        print("S")
    print("sss")
else:
    print("nmb")

12.条件表达式

num1 = int(input("输入第一个整数"))
num2 = int(input("输入第二个整数"))
#比较大小
if num1 > num2 :  #if 判断的实质是bool值为真
    print(num1, ">" ,num2)
else :
    print(num1, "<" , num2)

#条件表达式是if……else的缩写

print(num1 if num1 > num2 else num2)
#如果bool(条件)为true返回前面否则返回后面
#类似c语言的三目运算符 num1 > num2 ? num1 : num2

#pass 占着茅坑不拉屎
#当没想好时可以用pass先占着

if num > 1:
    pass
else:
    pass

13.range函数

‘’’
range函数用于生成一个整数序列
创建有三个方式
range(stop) 创建一个[0,stop）步长为1的整数序列 range(start,stop) 创建一个[start，stop) 步长为1的整数序列 range(start,stop,step) 创建一个[start, stop) 步长为step的整数序列
range对象所占用内存相同，因为只需要存储start，stop，step 只有用到
range才会计算序列中的相关元素
in 与 not in 用于判断range中是否有指定的整数
‘’’

#range()返回值是迭代器对象

r = range(1 , 7)
print(r)

#如果想查看其中的序列，使用list

r = range(0, 8 , 3)
r = list(r)
r.append([2 , 3 , 9])
print(9 in r[3])

14.while循环

while 条件:
执行体
判断N + 1次
执行N次

n = 0
ans = 0
while n < 100:
    n = n + 1
    print(n)

先判断n是否小于100
是执行n+1
否跳出循环

#计算0-100之间的偶数

n = 0
while n <= 100 :
    if n % 2 == 0:
        ans += n
    n += 1
print(ans)

15.for-in循环

in表达从（字符串 序列等）中依次取值，又称为遍历
for-in循环遍历的对象必须是可迭代对象

语法结构
for 自定义变量 in 可迭代对象 :
循环体

for j in "python":
    print(j)

for i in range(1 , 7) :
    print(i)

#如果不需要这个变量 可以用下滑线代替

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

#for循环计算1-100之间的偶数和

ans = 0
for i in range(1 , 101):
    ans += i
print(ans)

#for循环输出100-999之间的水仙花数
#每位的三次方之和等于本身就是水仙花数

for i in range(100 , 1000):
    ans = 0
    for j in str(i):
        ans += int(j)**3
    if ans == i:
        print(ans," ")

break 跳出循环
continue 立即进行下一次循环
#仅对命令所在的最内层循环生效

for i in range(100):
    if i % 2 == 0:
        continue
    else :
        print(i)

for i in range(100):
    if i == 77:
        break
    else:
        print(i)

16.else的其他应用

经典if-else搭配

num = 2
if num > 3:
    print("haha")
else :
    print("niub")

for-else搭配

#如果循环体正常执行完会执行else
#遇到break不执行

for i in range(233):
    print("hh")
    if i == 3: 
        break
else :
    print("ss")

for _ in range(3):
    passs = input("请输入密码")
    if passs == "888":
        print("密码正确")
        break
    else:
        print("密码错误")
else:
    print("密码错误三次，不能再输入")

while-else

同理

17.嵌套循环

#嵌套循环

#输出九九乘法表

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

j每次从1循环的i + 1 ，然后i循环至下一个i以此类推

18.列表

#变量可以存储一个元素，列表可以存储N个元素
#列表相当于其他语言中的数组

a = 10 #变量存储的是一个对象的引用

b = [1 , 2 , 3 , 4]
#该变量存储的列表对象的引用
#列表存储的是多个对象的引用

列表的创建

c = [1 , 2 , 3 , 4 , 5]

d = list([1 , 2 , 3 , 4])
#好像更麻烦了

列表的操作

列表的切片操作

列表名[start : stop : step]用 冒号 分隔

切片范围[start , stop)

b = a[1 : 6]
c = a[1 : 6 : 2]
d = a[6 : 1 : -1]

如果step为正数，不写start默认切片的第一个元素是列表的第一个元素
不写stop切片的最后一个元素默认为列表的最后一个元素
如果step为负数，不写start切片的第一个元素默认是列表的最后一个元素
不写stop切片的第一个元素默认是列表的第一个元素
start必须比stop大

列表中元素的查询

print(1 in a)
print("ss" not in a)

列表中元素的遍历

for i in a:
    print(i)

列表中元素的获取

获取列表中的单个元素

print(a[-1])
print(a[5])
#为什么可以有-1请看列表的特点
#输出相同

获取列表指定元素的索引

print(a.index(6))
#如果有多个相同的返回第一个的
#还可以在指定的start,stop之间进行查找
print(a.index(1 , 0 , 3))

列表中元素的添加

添加单个元素

print(a.index(6))
#如果有多个相同的返回第一个的
#还可以在指定的start,stop之间进行查找
print(a.index(1 , 0 , 3))
### 列表元素的增加
#### 添加一个元素

a = [1 , 2 , 3 , "python"]

append向列表末尾添加一个元素

a.append("Helloworld")
print(a)

extend 向末尾至少添加一个元素,用方括号括起来
(即添加一个列表的元素)

a.extend([1 , 2 , 3])
print(a)

b = ["ss" , "kkk"]
a.extend(b)
print(a)

insert 在一个指定位置插入一个元素，这个元素往后的元素后移

a.insert(0 , "nmb")
print(a)

向一个位置添加好多元素

aa = [1 , 2 , 3 , 4, 5 , 6]
bb = ["hello" , "sss" , "kk"]
cc = aa[1 :]#(切片，后面会说到)
aa[1 : ] = bb
aa.extend(cc)
print(aa)

列表元素的修改

指定索引元素赋新值

a = [1 , 2 , 3 , 4]
a[2] = "HelloWorld"
print(a)

切片赋值（连续）

a = [1 , 2 , 4 , 5]
a[1 : 3] = ["ss" , "asda" , "asd" , 1]
print(a)

列表元素的删除操作

直接删除元素

重复删除第一个

a = [1 , 2 , 3 , 4 , 5 , 6 , 7]
a.remove(7)
print(a)

删除索引的数

a = [1 , 2  , 4 , 5, 6]
a.pop(3)
print(a)

切片删除

步长只能是1

a = [1 , 2 , 3 , 4 , 5 , 6]
a[1 : 4] = []
print(a)

清除列表

a = [1 , 2 , 3]
a.clear()
print(a)

#删除列表

a = [1 , 2 , 3]
del(a)

列表元素的排序操作

调用sort

a = [1 , 4 , 7 , 2 ,4 ,5 , 1 , 9]
a.sort()
print(a)

指定reverse 进行降序操作

a = [1 , 2 , 3 , 1]
a.sort(reverse = True)
print(a)

调用内置函数sorted，产生新的列表

也可以给源列表赋值

a = [1 , 2 ,5, 3, 4, 9 , 8 , 2 , 7]
a = sorted(a)
print(a)

列表生成式

c = [i for i in range(11)]
print(c)
c = [i for i in range(2 , 11 ,2)]
print(c)

列表的特点

元素按照顺序有序排序
索引映射唯一一个数据
可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存

#索引       0   1   2   3    4    5   6     7     8    9
       a = [1 , 2 , 3 , 4 , 5.7 , 6 , 7 , "ss" , 9 , 10]
#索引      -10  -9  -8  -7   -6   -5  -4   -3   -2  -1

19.字典

#字典是一个可变序列 与列表一样
#以键值对的方式存储数据，字典是一个无序的序列 列表有序
#用花括号定义字典 方括号定义列表
#类似于C++ Map

a = {"a1" : 13 , "a2" = 15}
冒号前面是键，后面是值，一对叫键值对

#字典查找值是通过键的哈希计算得到值的位置，所以存入字典的键应该是不可变序列

字典的创建

也是两种方式

a = {
     "Alice" : 1 , "Bob" : 2 , "Cindy" : 3}

b = dict(Alice = 1 , Bob = 2 , Cindy = 3)

#第二种稍微简单一些

c = {
     } #空字典

字典中元素的获取

a = {
     "Alice" : 1 , "Bob" : 2 , "Cindy" : 3}

print(a['Alice'])

print(a.get('Alice'))

字典元素的判断

只能判断key

print("Alice" in a)

字典元素的删除

del a['Alice']

print(a)

#新增字典元素

a['Dave'] = 4

print(a)

字典元素的更新

a = ['a' : 1 , 'b' : 2 , 'c' : 3]
a.update('c' = 4)

字典视图操作

print(a.keys()) #获取a所有的键

print(a.values()) #获取a所有的值

print(a.items()) #获取a中所有键值对 与直接输出字典类似

字典元素的遍历

#获取的是字典的键

for i in a:
    print(i)
for i in a:
    print(a[i])

#或者

for i in a:
    print(a.get(i))

字典生成式

#zip会将两个可迭代对象的元素一个一个打包成元组 返回元组组成的列表
#长度是a , b当中短的

a = ['Alice' , 'Bob' , 'Cindy']
b = [1 , 2 ,3 , 4]
d = [(1 , 2 ,3) , (4 , 5 , 6) , (7 , 8 , 9)]
c = zip(a , b)
print(dict(c))

d = {
     i : j  for i , j in zip(a , b)}
print(d)

f = zip(a , b , d)
print(list(f))

print(a)

20.元组

‘’’
字符串 元组是不可变序列 没有增 删 改操作

列表、字典是可变序列 可以增删改，地址不变
‘’’

元组的创建

用小括号定义

a = (1 , 2 , "ss" , [1 , 2 , 3])

print(a)
#省略小括号

a = 1 , 2 , 4
print(a)

a = tuple((1 , 2 , 3))
print(a)

#只有一个元素的元组

a = (1 , )

print(a)

a = 2 ,

print(a)

#空元组

a =()
print(a)

元组的操作

#元组中元素引用不可变 但如果引用的是可变对象，可变对象可以修改

a = (1 , [1 , 2] , 3)

print(a)

a[1].append(1)

print(a)

#元组可以用 for 遍历

a = (1 , 2 , 3 , 4)

for i in a:
    print(i)

21.集合

集合的特点

#与列表 字典一样都属于可变的数据类型

#集合是没有value的字典
#集合中元素无序
#只有键没有值
#键只能是数和字符串

集合的创建

#直接花括号，集合元素不能重复

a = {
     1 , 2 , 3}
print(a)

a = {
     1 , 2 , 3 , 3}
print(a)

s = set(range(6))
print(s)

s = set([1 , 2 , 3 , 4])

print(s)

s = set('python')

print(s)

s = {
     }

print(s)

集合元素的相关操作

#依然可以用 in / not in

s = {
     1 , 2}
s.add(3) #一次添加一个元素
print(s)
s = {
     1 , 2}
s.update({
     4 , 5 , 6}) #只能加序列（多元素）
s = {
     1 , 2}
s.update(range(7 , 12))
print(s)

集合元素的删除

s.remove(1)
print(s)
#如果不存在会异常

#discard 如果元素不存在不会抛出异常
s.discard(2)
print(s)

s.discard(1)
print(s)

s.pop()#随机删除

s.clear()#清除

集合之间的关系

s = {
     10 , 20 , 40}
s1 = {
     10 , 40 , 30 , 20}

print(s == s1)

#判断s是否是s1的子集

print(s.issubset(s1))

#判断s1是否是s的超集
print(s1.issuperset(s))

#两个集合是否 没有 交集
print(s1.isdisjoint(s))

集合的数学操作

s1 = {
     10 , 20 , 30 , 40}
s2 = {
     20 , 30 , 40 , 50 , 60}

#求交集
print(s1.intersection(s2))
print(s1 & s2)

#求并集
print(s1.union(s2))
print(s1 | s2)

#求差集 
print(s1.difference(s2))
print(s1 - s2)
#就是s1中有什么s2没有的

#求对称差集
print(s1.symmetric_difference(s2))
#就是不是两边都有的元素

集合生成式

s = {
     i for i in range(5)}
print(s)

22.字符串

字符串的驻留机制

‘’’
Python支持短字符串驻留机制，对于短字符串，
将其赋值给多个不同的对象时，内存中只有一个副本，
多个对象共享该副本，与其他类型数具有相同的特点。
然而这一特点并不适用于长字符串，长字符串不遵守驻留机制
‘’’
‘’’
驻留机制的几种情况（交互式）
字符串长度为0或1 时
符合标识符的字符串
字符串只在编译时进行驻留而非运行时
[-5,256]之间的整数数字
‘’’

a = "python"
b = "python"

print(id(a))
print(id(b))

print(a is b)

a = "abc%"
b = "abc%"
print(a is b) #这里是true但是交互模式是false

a = "abc"
b = "ab" + 'c'
c = "".join(['ab','c'])

print(a is b) # b是编译时候完成的
print(a is c)# c是运行时完成的

字符串的操作

子串的查找

e = "abcdeafkasjlkjasdkljkjlasjdhgasdabs"
print(e.index('ab'))#子串第一次出现的位置
print(e.rindex('ab'))#子串最后一次出现的位置
#这两个如果不存在的话会返回valueerror

print(e.find('ab'))#子串第一次出现的位置
print(e.rfind("ab"))#字串最后一次出现的位置
print(e.find("sdadasd"))
#如果这两个不存在的话会返回 -1

大小写转换

print("ab3c和".upper())#所有字母转换成大写字母
print("Aba3H吗".lower())#所有字母转换为小写字母
print("ABcDeFg".swapcase())#大小写互换
print("aasdhjjkashd".capitalize())#第一个大写其余小写
print("i love python".title())#每个单词首字大写

字符串对齐

居中对齐

字符串在给定长度内居中，其他用第二个参数填充，不写为空格

a = 'pythoncharm'
print(a.center(20 , "+"))

左对齐

a = 'pythoncharm'
print(a.ljust(20 , "#"))

右对齐

a = "pythoncharm"
print(a.rjust(20 , "^"))

右对齐（只接受一个参数，指定字串长度）左边用0填充

a = "pythoncharm"
print(a.zfill(20))

字符串的劈分

split() 从左边开始劈分

默认劈分字符是空格，返回列表

s = "Hello python world".split();
print(s)

#指定sep参数为劈分字符

s = "Hello python world".split('l')
print(s)

#指定maxsplit参数为最大分割次数，达到后后面不会再分割，单独作为字串

s = "Hello python world".split('l', 1)
print(s)

rsplit() 从右边开始劈分

,当有maxsplit参数时

s = "Hello python world".rsplit()
print(s)

字符串的判断

判断字符串是否由合法标识符组成（字母数字下划线）

s = "sadasdasda"
print(s.isidentifier())
s = "asda*&6567"
print(s.isidentifier())

判断字符串是否由空白字符组成（回车换行水平制表符）

s = " \n"
print(s.isspace())

判断字符串是否全由字母组成（包括汉字）

s = "张三sss"
print(s.isalpha())
s = "ss1"
print(s.isalpha())

判断字符串是否全由十进制数字组成

s = '123'
print(s.isdecimal())

判断字符串是否全由数字组成（包括罗马数字）

s = "123Ⅴ"
print(s.isnumeric())

判断字符串是否全由字母数字组成

s = "张san4"
print(s.isalnum())

字符串的替换

s = 'abcabcabcacbabcabc'
#replace(需替换的子串，替换的子串,最大替换次数)
print(s.replace('abc' , 'zzz' , 3))

字符串的合并

#可以将元组或列表中的字符串合并，中间插入该字符串

a = ["123" , "456" ,"789" ,"777"]
s = "sss"
print(s.join(a))
s = ""
print(s.join(a))
a = ("1" , "2" , "3" , "4")
print(s.join(a))

字符串的比较

比较的是各位的ascii码（逐位比较），用比较运算符

a = "abc"
b = "abd"

print(a < b)

#用ord()获取ascii码 chr()将ascii码转换成字母

print(ord('s'))
print(chr(23333))

字符串的切片

a = "hello,python"
s1 = a[:5]
s2 = a[6:]
print(s1 + '!' + s2)

格式化字符串

1. %作占位符（与c语言一样）

name = "张三"
age = 20
print("我叫%s,今年%d岁" %(name , age))

2.花括号占位符{}

#format(1 , 2 , 3 , ....)
#花括号标0使用format中的第一个参数一次类推

print("我叫{0} , 今年{1}岁 ， 我真的叫{0}".format('张三' , 23))

3.f-string

print(f"我叫{name} ， 今年{age}岁")

23.函数

函数的定义

python中函数的定义模式为

def 函数名:
函数体

def calc(a , b): #a ,b 称为形式参数
    #形参的位置出现在函数的定义处
    c = a + b
    print(a , b)
    return c

result = calc(10 , 20) #10 ， 20称为实参值，实际参数的值
#实参的位置出现在函数的调用处
print(result)

函数中参数的传递

按照位置传递

result = calc(10 , 20) #10给了a，20给了b

关键字传递 根据形参名称传递

result = calc(b = 10 , a = 20)

def change(a , b):
    a = 14
    b.append(12)
    print(a , b)

n1 = 11
n2 = [1 , 2 , 3 , 4]
print(n1 , n2)
change(n1 , n2)
print(n1 , n2)

'''
实参传入函数时，a与n1指向相同，b与n2指向相同
修改时，a直接指向了其他地址，b还是指向n2的地址
所以返回时n1值不变，n2值变了
'''

函数的返回值

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

def fun(num):
    ou = []
    ji = []
    for i in num:
        if i % 2 == 0:
            ou.append(i)
        else:
            ji.append(i)
    return ou , ji

a = fun([10 , 29 , 34 , 23 , 44 , 53 , 55])
print(a)
print(a[0] , a[1])

#函数定义时，可以给某参数设置默认值

def  fun(a ,b = 10):
    print(a , b)
fun(10)   #默认传给a
fun(10 , 30) #30会将b默认值覆盖

不确定传参(封包)

位置传参

def func(*argc):
    print(argc) #结果为元组
func(1 , 2 , 4 , 5)

关键字传参

def func(**argc):
    print(argc)
func (a = 1 , b = 2 , c = 3)

不确定传参(解包)

* 与 ** 同样可以将已经封包的序列和字典解包

a = [1 , 2 , 3];
def funcf(a , b , c):
    print(a , b , c)
funcf(*a)

b = {
     'a' : 1 , "b" : 2 , 'c' : 3}
def funcc(a , b , c):
    print(a , b , c)
funcc(**b)

24.永久存储

文件的打开与读取

函数原型open(file , mode = 'r' , buffering = -1 , encoding = None , errors = None ,newline = None , closefd = True , opener = None)

f = open(r"C:\Users\LIYINUO\Desktop\record.txt")#打开文件
f.close()#关闭文件	

文件的打开模式

‘’’
'r' , 以只读的方式打开文件
'w' , 以写入的方式打开文件，会覆盖已存在文件
'x', 如果文件已经存在，使用此模式打开会引发异常
'a' , 以写入模式打开，如果文件存在，则在末尾追加写入
'b' , 以二进制模式打开文件
't' , 以文本模式打开（默认）
'+' , 可读写模式（可以添加到其他模式使用）
'U' , 通用换行符支持
‘’’

文件对象的方法

close() 关闭文件
read(size = -1) 从文件中读取size个 字符 ，当未给定size或者给定负值时，读取剩余所有字符， 并以字符串的形式返回
readline() 从文件中读取一整行字符串
write(str)将字符串str写入文件
writrlines(seq) 像文件中写入字符串seq，seq应该是一个可以返回字符串的可迭代对象
seek(offset , from) 在文件中移动文件指针，从from（0代表文件的起始位置，1代表当前位置，2代表文件末尾）便宜offset个字节
tell()返回当前文件中的位置

文件中的读取与定位

f = open(r"C:\Users\LIYINUO\Desktop\record.txt" ,  encoding='UTF-8') #用utf-8编码打开文件
f.read()
f.close()

#输出

【环球网快讯】美国《国会山报》刚刚消息，当地时间23日，密歇根州竞选委员会确认了该州的选举结果，
乔·拜登在总统竞选中击败特朗普。报道称，这是“对特朗普的又一次打击。”ajdjkashdhask暗杀的夸奖哈
飒飒客户端尽快哈数据库的和骄傲和数据库的会尽快撒谎的尽快哈数据库喀什的空间哈桑艰苦的环境卡刷点
卡哈手机客户端卡省的哈萨克结婚登记卡省的拉萨河就卡死'

#如果read()不设参数，则会全部读完，文件指针会指向末尾

f.tell()会告诉你当前指针在哪里
#输出

494

文件指针以字节计数

文件指针的移动

函数原型seek(offset , from)
从from开始移动offset个位置 from 0 为文件起始 ， 1为当前位置 ， 2为文件末尾

f.seek(0,0)
f.read(5) #输出【环球网快
f.tell() #输出15（utf-8编码一个汉字字符三个字节）

f.readline()用于读取一行
输出

'【环球网快讯】美国《国会山报》刚刚消息，当地时间23日，密歇根州竞选委员会确认了该州的选举结果，\n'

#文件中的内容可以放入list中，每换一行是一个元素

a = list(f) 
print(a)

#因此文件也支持迭代
for i in f:
    print(i)

f.close()

#输出

#输出
'''
乔·拜登在总统竞选中击败特朗普。报道称，这是“对特朗普的又一次打击。”ajdjkashdhask暗杀的夸奖

哈飒飒客户端尽快哈数据库的和骄傲和数据库的会尽快撒谎的尽快哈数据库喀什的空间哈桑艰苦的环境卡

刷点卡哈手机客户端卡省的哈萨克结婚登记卡省的拉萨河就卡死
'''

文件的写入

确保打开模式有‘w’或者 'a'

f = open(r"C:\Users\LIYINUO\Desktop\record.txt" , "a" , encoding = 'UTF-8')
f.write("sd") #返回写入的字符数量

25.类和对象

————我的梦想是面向对象编程
类和各种数据结构都是来源于封装的概念，不过数据结构只能封装数据，类要高级一些，可以对代码进行封装。

创建一个类

class Students: #类名一般要大写
	aspect = "People"
	age = 17 #对象的属性
	def printmessage(self)
		print("这个学生今年 %d 岁" % self.age) #对象的方法

创建一个对象

只有一个类是不够的，就好比做玩具只有模具，没有根据模具做出来的东西

a = Student() #根据类创建一个对象，叫实例对象

我们可以通过实例对象调用类里的属性和方法

>> a.printmessage() 
>> 这个学生今年 17 岁

>> a.aspect
>> "people"

>> a.age
>> 17

理解self

我们先来看这样一段代码

class Fish:
	age = 14
	def changeage(self):
		self.age = 12

a = Fish()
b = Fish()

a.changeage()

print(a.age , " " , b.age) # 结果输出12 和 14

这段代码什么意思呢
a 和 b 都是Fish的实例对象，a.age 和 b.age都是14，但是a调用了类中的changeage()将自己的age改为12，所以self其实就是将自己传进去，然后修改他的成员。

class Fish:
	def setname(self , Name):
		self.name = Name
		print("i am %s and nice to meet you" %s self.name)

a = Fish()
a.setname("Panic")
#输出i am Panic and nice to meet you

__init__()

__init__()是创建实例对象时自动执行的方法

class Fish:
	def __init__(self , Name , Age):
		self.name = Name
		self.age = Age
a = Fish("chino" , 13)
print(a.name , " " , a.age)#输出chino 13

我们创建了 a 的实例对象后，init自动帮我们把name 和 age 赋值

公有和私有

Python中并没有类似c++的public 和 private关键字修饰，但也不代表所有的变量都可以从外部访问
在c++中

class fish
{
     
	public:
		int age = 3;
	private:
		char sex = 'M';
}
int main()
{
     
	fish a;
	printf("%d" , a.age);//这句话没问题
	printf("%c" , a.sex);//这句话会报错
}

python中

class Fish:
	age = 3
	__sex = 'M'
a = Fish()
print(a.age) #这句话没问题
print(a.__sex) #这句话会报错	

在变量名之前加入__修饰可以将变量变成私有，不能从外部访问
但其实这只是对变量改名了而已
使用实例对象._类名.__函数名依然可以访问

print(a._Fish.__sex)

类继承

类也分大类和小类，假定我们定义了鱼类，但后来我们又要定义金鱼类、鲨鱼类、带鱼类等等。如果我们将鱼类的共同点再在后来定义的小鱼类里写一遍就太麻烦了。于是就有了类继承机制。

我们可以这样实现类继承

class Fish:
	def __init__(self , name , sex):
		self.name = name
		self.sex = sex
	def printmessage(self):
		print("i am %s who is a %s fish" % (self.name , self.sex))

class Sharks(Fish): #定义鲨鱼类，继承鱼类
	hungry = 0

a = Sharks("Pipper" , "Male") #调用父类的__init__()
a.printmessage() #调用父类的成员函数

这里我们称Fish类也就是被继承的类为基类、父类或者超类
继承者称为子类
一个子类可以继承父类的任何属性和方法

需要注意的地方

如果父类和子类中有相同的方法或变量的话，会优先调用子类的。
如

class Fish:
	def __init__(self , Name):
		self.name = Name
class Sharks(Fish):
	def __init__(self , Sex):
		self.sex = Sex
a = Sharks('M')
#如果现在输出a.name会报错，因为调用的是sex，不是name