Python基础学习笔记

入门

1.“人生苦短，要学python”

易学（崇尚优美、抽象级别高、屏蔽底层细节更接近人类语言）

好用（开发效率高、标准库、第三方库、庞大的用户基数）

2.使用

适用领域：web、自动化、数据分析、运维、游戏、人工智能、图像处理

不适用领域：手机App(Java、 objext c、Swift)、web前端（css、js、html）

3.安装

1.python3、32位版本

​ -->Python 2从2020后，官方已不再维护)–>建议安装比最新版本低的版本

–>有些库，64位可能加载不了

–>开源，官网下载即可https://www.python.org/getit/

–>安装时勾选Add python3.6 to PATH会自动配置环境变变量(尽量不要安装C盘)

2.Pycharm

4.运行方式

解释：

python 不需要编译成机器代码，通过解释器解释执行（有多少行执行多行，有问题了停止）

​ -->内部是C语言

​ -->跨平台，Linux、Windows、Mac

编译：

​ -->cpu+内存=大脑(CPU只懂机器指令:从哪个地址读写数据、跳转到哪个地址继续执行指令)

​ -->二进制可执行程序里面包含机器指令

​ -->比如C语言，编译+链接，产生机器代码

对象

定义：python一切切皆对象,所有的数据类型都是对象

变量

'''
1)一般变量以字母开头,不能用数字、特殊符号比如下划线开头,也不建议用中文**
2)大小写敏感,大小写意义完全不一样**
3)不能与关键字同名,解释器有特定意义的名称,可打印查看关键字
    import keyword
    print(keyword.kwlist)
4)不能与函数名称同名**
5)见名知意**
6)不需要声明变量类型,赋什么类型的值就是什么类型的**
7)变量操作: a+=1 等于 a=a+1     a /=1 等于 a=a/1   乘\* 减- 也是**
'''
import keyword
print(keyword.kwlist)

'''输出结果参考如下：
['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']
'''

字符串

1-定义：成对引号引起来（单引号、双引号、三引号）

str='abxd'
str1="adcde"
print(type(str1))

转义符:

#\n换行符
str3='adcd\ne'
print(str3)

2-使用场景：

'''
1- 字符串对象
2-路径 'd:/test.txt'
3-url  web_url='www.gaosiedu.com'

单双引号混合用法 web Ui自动化识别元素:
driver.find_element_by_xpath("//*[@id='kw']").send_keys("test")
三引号：辅助注释
'''

3-拼接

print('name is'+'yangmin')
print('hello'+3) #此处的+系统认为是拼接符，因此后边必须为字符串，和数字拼接会报错
print(3+'hello')#也会报错，但是系统遵循先入为主，先判断3，然后认为+为运算符
#拼接总结：遵循先入为主

4-sequence的操作

'''
字符串的特性，被称为sequence(序列) 有编号的都叫序列，正下标、负下标：字符串、元组、列表
一个序列，若干个元素组成
'''
str4='abcde'
print(str4[0])

#字符串元素获取--下标获取
print('长度：----->',len(str4))
print(str4[6])#没有这个元素，系统会报indexErro： str index out of range
print(str[-1])#倒数第一个元素

#字符串不能使用下标去修改，只能重新赋值
str4[0]='X'  #TypeError: 'type' object does not support item assignment

#负下标
print(str4[len(str4)-1]) 

5-切片操作

str5 = 'abcde'  
#获取中间一段，切两刀[第1刀：你需要获取字符串中的第一个元素的下标][第2刀：第一刀下标+你需要获取字符串长度]
#获取元素的下标
print(str5.index('b'))
print(str5[1:1+3])
'''
	1-切片使用下标操作
	2-切片不影响原数据类型
	3-获取的数据类型与原数据一致
	4-左含右不含 eg:print(str5[1:4]) 包含下标为1的，不包含下标是4的
'''

#获取前半段：写前取后，写后取前（或缺前半段后边下标的值，获取后半段写前边下标的值）
str6='abcde'
print(str6[:2])

列表

1-列表：也是一种Sequence类型，有下标，可切片，可以存储任何类型

#定义
alist = [10, 'hello', 3.14, [100.200]]
print(type.alist())
# 取值--一个值：下标 多个值：切片
print(alist[0])
print(alist[-1][0])  # 两层列表取内层列表的值，最后取到100
print(alist)

2-修改

#修改
alist[0] = 20
print(alist)
alist[-1][0] = 300
print(alist)

3-增加元素

#增加
alist1 = [10, 20, 30]
alist.append(50)  # 尾部增加
alist.insert(0, 100)  # insert(需要插入的位置下标，需要插入的值),可以插入列表
# insert插入的位置下标>len 相当于尾部增加，不会增加，比如alist.insert(4,100)
print(alist)

4-删除

alist2 = [10, 20, 30, 40]
# del方法
del alist[0]
print(alist)
# 删除多个
del alist[0], alist[1]  # 删除下标为0的元素--[20，30,40],再在排序的基础上删除下标为2的，结果为[20,30]
# 跳跃删除
del alist[::2]  # 删除20和40，剩下10,30

# pop方法  有返回值---返回被删除的对象
alist3 = [10, 20, 30, 40]
res = alist3.pop(2)
print(alist3)
print(res)

# remove---根据值来删除---判断值---三种里面效率最低（通过遍历去匹配）
alist4 = [10, 20, 30, 40, 30, 50, 30]
alist.remove(30)  # 只能删除第一个

# 想全部删除30---元素存在，一直删
while 20 in alist:
    alist.remove()
print(alist)

# 合并列表
# 1- 临时合并---另存新地址--新对象(用+拼接符拼接，原列表没变)
alist5 = [1, 2]
print(alist5 + [40, 50], alist5)  # id(),校验列表的地址看是否同一个地址
print(alist5)

# 2-同一个地址--扩展原列表（已有地址扩展列表）
alist5 = [1, 2]
alist5.extend([40, 50])
print(alist5)

'''
汇总：
	1-列表是---可变对象
	2-任意类型--存储

'''

元组

1-定义：元组也是一种Sequence类型，可以存储任意类型的数据，每个元素是任意类型

#1-元组合列表非常相似，有一个最大的不同,元组不能改变其组成元素（immutable）
#2-元组---只读---不可改变:元素个数、元素的值
#元组只有一个元素时，后边必须加逗号
tu1=(1,)
tu21=(1,2,3)
print(type(tu1))

'''
使用场景：
	1-列表：存储数据--可以修改的、排序
	2-元组：一些项目的系统配置数据----不能修改
		systemConfigData = ('xxx = false')

案例场景：
需求：
	1-保存全班学生的信息
	2-可以修改每个学生的信息
	3-可以增加、删除-学生的信息
stuinfo=(
		[学生1学号，姓名，电话，邮箱]
		[学生2学号，姓名，电话，邮箱]
		[学生3学号，姓名，电话，邮箱]
)
以上整体放在一个元组，具体每个学生的信息放在列表
'''
info=([100.200],[300,400],[400,500])
info[0][0]=30
print(info)
print('-----',id(info))

2.元组–列表互相转换

#转换后为全新对象
a=[1,2,3]
b=(2,3,4)
list(b)
tuple(a)

常识总结：
1.python大小写敏感
2.变量名称不能用数字开头
3.float支付的浮点数为16位
4.python一切数据均为对象
5.没有任何变量引用的对象，最终会被解释器清除

布尔表达式

1.定义

'''定义:只有两种结果：真 假'''
boolData = True
# 2-关系运算符：> < >= <= ==  !=
print(3 == 1)  # 两个等于号是等于  一个等于号是赋值
# print(3=1)#此处语法错误，SyntaxError: keyword can't be an expression

# 3- is  #是不是同一个对象
a = 100
b = 100
a == b  # True python存储机制，节省内存，当<=256时，a b都指向了同一个内存地址，想验证话可以用id验证 id(a)
# 超过256的话会开辟新地址，c=257 d=257  c=d False

# 4-字符串比较大小
print('abc' > 'bc')  # False 比较对应位置的ascll码大小，a->97 b_>98 (记忆法：A--65  a--97)

# -in 在...里边，用的较多，比如断言时，校验页面包含某个元素
str1 = 'abcde'
# 1-in字符串：前者是后者的一个元素  2-前者是后者的连续一段
print('a' in str1)
print('abc' in str1)
str2 = '欢迎xx登录高思系统'
print('杨敏' in str2)

# 2-in 列表 数据存储里使用---前者是后者的一个元素
alist = [1, 2]
print(a in alist)
print(alist[2:0 + 2] in alist)  # False 没有连续的概念，只能是前者是后者的一个元素

2-条件组合

'''2-条件组合'''
'''逻辑条件
 1-且 and(全真为真，一假为假)
 	条件1 and 条件2
 	1-条件1为真，条件2一定会运行
 	2-条件1为假，条件2一定不会运行
 2-或 or(一真为真，全假为假)
 	条件1 or 条件2
 	1-条件1为真，条件2一定不要运行 比如：if xxx or 函数（）  此时xxx为真，后边的函数没机会运行
 	2-
 3-不 非 not
'''
print(3==1 and 2>0)
#混合运算，算术运算符>关系运算符>逻辑符
#优先级 not>and>or 适当打上括号，方便理解逻辑，维护代码比较好理解
print(not 1>2 or 4>3 )   #有真则真

# 常识总结
# python的赋值，深拷贝和浅拷贝的区别?
'''
项目场景：
	一个接口api_A获取到数据-sData
	需要：
	1-接口a 调用数据源sData
	2-接口b 调用数据源sData
	期望：接口a调用完数据源，不会改变数据源
总结：
	1-如果数据源是一层列表--使用拷贝都是可以---深/浅拷贝
	2-如果是多层---深拷贝（在一个项目里，数据需要完全隔离）
	3-赋值----同一个对象----相互没有关联，A接口调完后,B接口再用A接口的结果

'''
# 方案1--赋值操作
alist = [10, 20, [111, 22]]
blist = alist
print("alist内存地址--->", alist, "id-->", id(alist))
print("blist内存地址--->", blist, "id-->", id(blist))
'''
执行结果（可以看出 ab都指向同一个地址，因此这个方法的拷贝不可行）
alist---> [10, 20, [111, 22]] id--> 2293614217224
blist---> [10, 20, [111, 22]] id--> 2293614217224
'''

# 方案2--浅拷贝
# 拷贝的比较浅
# 外层列表是独立的，互不影响
# 子列表是同一个，数据没有完全独立
import copy  # 导入模块
clist = [10, 20, [111, 22]]
dlist = copy.copy(clist)  # 调用copy模块下的copy方法，操作后会发现
def demo1():
    # 1-copy后，只修改外层结构数据
    dlist.append(30)
    print("clist--->", alist, "id-->", id(clist))
    print("dlist--->", blist, "id-->", id(dlist))
    '''执行结果如下：（用copy方法后，只修改外层数据，乍一看，对原数据clist列表没有影响）
    clist---> [10, 20, [111, 22]] id--> 2646630490056
    dlist---> [10, 20, [111, 22], 30] id--> 2646630766664
    '''
# 2-copy后，修改内层列表结构数据
def demo2():
    dlist[-1].append(30)
    print("clist--->", alist, "id-->", id(clist))
    print("dlist--->", blist, "id-->", id(dlist))
    '''执行结果如下：(用copy方法得到dlist后，可以看到在修改dlist后，原clist的结构也被改变）
    clist=[10,20,[111,22，30]]
    dlist=[10,20,[111,22，30]]
    -------------->由此可见，copy方法，此种拷贝还不是完全独立--引出深拷贝的概念
    '''

# 方案3--深拷贝
import copy

clist = [10, 20, [111, 22]]
dlist = copy.deepcopy(clist)  # 调用copy模块下的deepcopy方法，操作后会发现

# 1-deepcopy后，修改外层列表结构数据
def demo3():
    dlist.append(30)
    print("clist--->", alist, "id-->", id(clist))
    print("dlist--->", blist, "id-->", id(dlist))
    '''执行结果如下：（用deepcopy方法后，只修改外层数据，对原数据clist列表没有影响）
    clist---> [10, 20, [111, 22]] id--> 1817957013512
    dlist---> [10, 20, [111, 22], 30] id--> 1817957904008
    '''
# 2-deepcopy后，修改内层列表结构数据
def demo4():
    dlist[-1].append(30)
    print("clist--->", clist, "id-->", id(clist))
    print("dlist--->", dlist, "id-->", id(dlist))
    '''执行结果如下：(用deepcopy方法得到dlist后，可以看到在修改dlist后，原clist的结构没有改变）
    clist---> [10, 20, [111, 22]] id--> 1817957014728
    dlist---> [10, 20, [111, 22, 30]] id--> 1817957013512
    '''
# 课外作业：了解下可变类型、不可变类型(https://www.cnblogs.com/fiona128/p/9501520.html)
#可变和不可变，本质上就是改变了里面的数据后，内存地址是否有改变

条件判断

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-poLb3Jf5-1601374339284)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200728201539771.png)]

#条件判断

#1-if语句--单条语句
#使用场景：只需要对
#控制台输入 input()  返回值是str   2.回车结束输入
score=input('请输入分数：')
if scrore >=60:
    print("恭喜，及格！")

#2-if-else---如果--否则
#使用场景：满足或者不满足都需要处理
srore =int (input('请输入分数：'))
if score>=60
	print('恭喜，及格！')
else:
    print('好好加油！')
    
#3-if elif
#使用场景：多分支--条件数量>2（分数要分ABCD等级）
score =int (input('请输入分数：'))
if score>=90
	print('A等级')
elif score>=80
    print('B等级')
elif score>=70
    print('C等级')
elif score>=60
    print('D等级')
else:
    print("好好加油")
    
 

初始函数

# -*- coding: utf-8 -*-
# @author: YangMin
# @describe: 初始函数
# @created on: 2020/7/29 11:46
''''''
'''
 1-什么是函数
 2-函数有什么
 3-函数怎么使用

变量的概念？
回顾变量：变量=值（对象）---方便后续的维护调用
在编程里,需要表达一段代码（一部分操作），而且这段代码会后续经常使用--->解决方案：函数（so,函数就代表一段代码）

问题？怎么定义函数？
定义函数:就是声明的概念--不会运行函数内部代码
大纲：
    1-函数定义与调用
    2-参数与返回值
    3-内置函数
'''

'''1-定义函数'''


# 定义函数---就是声明的概念，不会运行函数内部的代码
# 缩进--往后缩进TAB，往前缩进shift+tab
def demo():  # 起名见名知意
    print('Hello world\nTomorrow will be better!')


# 1.1-希望代码运行--函数调用
# demo()


'''2-参数'''
# 函数定义的，如果只有变量名，没有其他符号--必填形参
# 形参：函数定义的时候写入--必填形参；函数调用的时候，必须个数跟定义的一样
# 实参:实际传入的参数--函数调用
# python参数形式：https://www.cnblogs.com/poloyy/p/12526592.html


'''3-调用 return'''
'''
函数关联，后边函数需要使用前边函数的返回值
工作场景：
    a同事:负责写一个求和函数，det get_sum(a.b)
    b同事：使用a同事的函数结果，求自己需要的2个数的和
汇总：
    1-返回值是一个函数的结束
    2-在return后，后面可以是1个对象---函数调用接收到的值--就是该返回值的类型
    3-在return后，后面可以2个对象以上---函数调用接收到的值--就是元组（比如下边的）
'''


def get_sum(a, b):
    # print(a + b)
    return a + b
    # print('') #return返回值是一个函数的结束，因此下边的代码并不会运行


def get_sum1(a, b):
    return a, b, a + b  # 此处返回3个对象，函数调用接收为元组


def demo1():
    res = get_sum1(1, 2)
    print(res)


res = get_sum1(1, 2)
print(res)


# get_sum必须有return,demo2调用，才能用来+10
def demo2():
    res = get_sum(3, 2) + 10
    print(res)


# 扩展问题：一个函数里面，并不是是只有一个return，通常是结合在一起
def demo3(a, b):
    if a > b:
        return 1
    elif a < b:
        return -1
    else:
        return 0


def demo4():
    if demo3(10, 20) != 0:
        print("不相等")


'''
4-内置函数--直接调用
类型转换函数:str() int()  float() list() tuple() 
input内置函数 
'''


def demo5():
    alist = [10, 20]
    print(str(alist), 'len---->', len(str(alist)))  # 将a列表转换为字符串


# 1-int()---转换成 int---里面一定是数值整数才行，不能有小数点
# 1-字符串---int()---int
def demo6():
    str1 = '100'
    print(int(str1))
    str2 = '100.5'
    print(float(str2))


# 2-  小数(浮点数)---Int（）---int取整数位
def demo7():
    print(int(3.99))  # 输出只要整数位


# 3- list--tuple相互转换(转换后为全新的对象)
def demo8():
    a = [1, 2, 3]
    b = (2, 3, 4)
    print(list(b), "-->这是原来的元组b转化后")
    print(tuple(a),"-->这是原来的列表a转化后")

#input函数：1.不输入一直等待 2.敲回车结束输入 3.返回值是字符串
def demo9():
    name = input('请输入学员姓名：')
    if name:
        print("姓名输入不为空，继续下一步判断")
    else:
        input("姓名输入不允许为空，请您重新输入!")
#input常见错误(！input默认输出为字符串类型，因此需要转换成int,才能和整型相加)
def demo10():
    score=input("请输入您的成绩：")
    print(score+20)#

if __name__ == '__main__':
    # get_sum(1,2)
    demo9()

对象的方法

'''
1-函数：
    1-在一个xxx.py文件中
    2-函数的调用  test()
对象的方法：
    1-本质也是一个函数--这个函数不在xx.py里面定义，在class（类）定义的
    2-函数是在..py里边，直接以def顶格写入，方法是在class类下边，def开头不顶格写入的
    3-调用方式不一样：对象名.方法()
'''
# 方法调用 对象名.方法名
# def demo():#函数
#     pass

# "bcc".strip()#调用的方法

'''2-字符串方法'''
# 1-count 计算字符串中包含的多少个指定的字符串（count方法返回的类型为int，代表个数）
info = 'abcdea'
# print(info.count('a'))
if info.count('X') != 0:  # 检查点--断言
    print("X 在这个字符串里面")
# 2-endswitch  检查字符串是否以指定的字符串结尾
print(info.endswith('a'))  # 返回为布尔类型，进行后端判断，比如校验手机尾号

# 3-find 返回指定的字符串（一个元素/多个连续元素）在字符串中出现的位置
# 查找--不清楚结果--找---2种结果：能找到、找不到
# 默认返回第一个改元素出现下标--正下标
# 没有找到--返回-1
info1 = 'abcdeb'


# print(info.find('b'))

def my_find(instr, unit):
    if unit in instr:
        return instr.index(unit)
    else:
        return -1


print(my_find(info, 'x'))

# 找出一个字符串里边一个元素所有位置的下标
info = 'ancdea'
idxlist = []
for one in range(0, len(info)):
    if info[one] == 'a':
        idxlist.append(one)
print(idxlist)

# 4-index 求元素的下标--这个元素一定要存在才行，如果不存在去查询会报错
# index---如果多个元素的下标，第一个元素的下标
print(info.index('b'))

# isalphs 检查字符串中是否都是字母
# isdigit 检查字符串中是否都是数字
'''
需求：
    1-要求输入用户手机号
    2-判断手机的运营商
    3-对用户输入的手机号有误需要给出对应的提示！
问题：
    1-移动 = [134,188]---身份证 手机,id 订单号--->使用字符串,勿用int，用int的话会埋下坑，input出来的是str，还需要转换
    2-可以使用临时变量(这个变量使用了很多地方)--好调试、维护
    3-出问题去调试

编程思路分析：
def Judge_operator():
    telnum = input("请输入学员手机号:")  # input默认返回是字符
    int(telnum)
    #if 1-判断是否是纯数字：
        #2-判断手机位数：
            #3-获取号段-temp
            temp = telnum[:3]
                if temp 是移动：
                    移动
                elif temp 是联通：
                    联通
                elif temp 是电信
                    电信
            else:
                不存在该号段
        else:
            提示位数不对！
    else:
        提示输入不是纯数字！
        
'''

#5-split 切割，返回是列表
info = 'abcaec'
print(info.split('c'))#c是切点，切点会被切掉，留下ab、de、空元素（一刀两段、两刀三段 ）

#lower 将字符串里面如果有大写字母全部转换为小写字母
#upper 将字符串里面如果有小写字母的全部转化为大写字母
print('CHINA'.lower())
print('hello'.upper())

#replace 替换字符串里面指定的字符串---默认是全部替换（可以指定替换几个元素）
info="Tom,Torrow will better,\nTom,come on!"
print(info.replace('Tom','jack',1)) #旧元素放前边，新元素放后边替换就可以

#-strip 将字符串前置空格和后置空格删除,中间的空格不能去
info = '  abcxxxcde '
print(info.strip())

#扩展
'''
需求：去掉info所有空格
方案一：
    1-info.strip()----去掉头尾的空格
    2-xx.split('')
    3-xx.join([xx,xx])
    info = 'a c d'
    
方案二：
    info.replace(' ','')将空格替换成空
'''
info = 'a c d'
#print(info.replace(' ',''))
temp=info.split(' ')
print("".join(temp))

字符串格式化

'''字符串格式化
1-概念：表达描述一个字符串---就是一个字符串
使用场景：往字符串里面传入对应的值
学习目标-
    方案1：
    方案2：
'''''
#1-字符串的描述--传统方案
#可读性不好，比较麻烦
# name='Tom'
# age = 20
# info ='我叫：'+name+'年龄: '+str(age)
# print(info)

#方案1----% 要求以字符串的形式传入
#%s,表示参入参数为字符串（如果是Int会强制转成str传入，如下的age）
#%d,转换成有符号十进制数（十进制比如：工资、年龄）
#%f,转换成浮点数
#%x,转成无符号十六进制数（十六进制：协议通信层）
# name='Tom'
# age = 20
# info = '我叫：%s,年龄是：xx'% name
# info = '我叫：%s,年龄是：%s'% (name,age)#参数传入的顺序严格参考位置
# print(info)

#字符串格式化
print('%5d' % 56)#指定传入的宽度为5，但是后边只给传两位，宽度为正，右边传入参数，左对齐
print('%1d' % 56)#指定传入的宽度<传入数据本身宽度,该要求不理会

#十六进制
print('%X' % 108)#(16进制可以用电脑计算器算下)

#浮点数---默认是6位，四舍五入
print('%f' %  3.1415926)
#想保留指定的小数位数--.n
print('%.2f' % 3.1414926)

#实际应用
#接口自动化---requests---body

#方案2:使用了字符串对象.format()
#位置一定不能空着，否则会报越界错误（前边是几个位置，后边必须传几个，一个萝卜一个坑）
#<左对齐，右补齐；<右对齐，左补齐;^中间对齐  :这个冒号代表指定宽度（字符串是左对齐右补齐 Int右对齐左补齐）
#1-顺序传值
name="Tom"
age="20"
info='我叫:{:^6},年龄是{:^6}' .format(name,age)#中间对齐
info1='\n我叫:{:>6},年龄是{:>6}' .format(name,age)#右对齐
info2='\n我叫:{:<6},年龄是{:<6}' .format(name,age)#左对齐
print(info,info1,info2)

#2-下标传值,下标对应右边传入的值的位置，下标放在冒号:
info3='\n我叫:{0:<6},年龄是{1:<6}' .format(name,age)

#3-变量传值，比较麻烦，不建议用
info4='\n我叫:{name:<6},年龄是{age:<6}' .format(name='tom',age=20)

#pychon3.6之后的版本---f''  最好用的传值方法
info5=f'我叫:{name},年龄是{age}'
print(info5)

读写–open函数

1-文件的读

# 1-文件打开--openopen  fileName---路径+文件名+后缀名

# 路径写法实例
fileDir = 'G:/a.txt'
fileir2 = 'G:\\a.txt'  # 注意用双// 单个是转义符
fileir3 = r'G:\a.txt'  # r取消转义

# 相对路径---当前路径 ./
fileDir4 = 'D:\yangmin.txt'
fo = open(fileDir4)  # 打开后，文件对象放到缓存里 fo---file object,用来接收open的内容放到内存
print ("操作前的文件指针--->", fo.tell())
print (fo.read(4))  # 不填参数--全部读取，学参数的就是读取个数
# print (fo.read(2))
print ("操作后的文件指针--->", fo.tell())

2-文件的写

'''文件内容写入'''
# 写模式--W
# 只是为了写文件而打开文件，如果文件已经存其内容则会清空，如果文件不存在，则创建一个文件
# 2- 写
fileDir5 = 'D:\yangmin.txt'
fo = open(fileDir5, 'w')  # 由于该文件本身就存在，因此写入时文件内容被清空
fo.write('abcd\nABCDEF')

字典

1-字典的属性

'''列表回顾'''
##怎么存储信息
nameList = [
    ['Mike', 25, 180, 80],
    ['Tom', 25, 180, 80]
]
#如果查询tom的年龄
print (nameList[1][1])
#但是后续业务--->如果里边增加了一个元素，由于这个是序列类型的，因此上边的查询查询出来的成了Jack的年龄
nameList.insert(1,['Jack',30,175,80])
print (nameList[1][1])
'''
序列类型在一些数据发生变化--下标会发生变化，后续的代码需要维护
急需--不是序列类型--没有下标的概念
'''

#无序的---字典
# eg:小时候有人喜欢背新华字典，但是一旦页码改变了...这个时候如果他是通过偏旁部首来映射记忆的话就能解决这个问题，即引入字典
dict={'name':'Tom','age':'20'} #两个键值对，通过键-->去找值
print(dict)
#1-字典的特性，特性决定用途
'''
特性：
    1-键值对形式
    2-无序的
定义：
    键：一定是：不可改变的类型
        可以是:字符串、int、float、元组
        不可以是：列表（可变）、字典---->TypeError: unhashable type: 'dict'
    值：可以任意类型    
'''

2-字典的操作

#2-字典的操作
dict1={'name':'Tom','age':'20','data':{'id':'001','data':'20200601'}}
#1-查询
print(dict1['name'])#单个字典查询
print(dict1['data']['id'])#字典套字典查询

#2-修改值
dict1['name']='jack'#修改会覆盖
print(dict1)

#3-增加元素--前提：要增加的这个键不存在
dict1['weight']=180#会把新增的元素默认增加到最后
print(dict1)

#4-删除元素--一起删除键值对
dict2={'name':'Tom','age':'20','data':{'id':'001','data':'20200601'}}
del dict2['name']
dict2.pop('age')
print('删除后的dict2为--->',dict2)

#5-查看元素个数
print(len(dict2))