三、Python基础（2）

（一）字典，dict全称“dictionary”，使用键值对（key-value）存储。各元素对应的索引或者下标称为键（key），各个键对应的元素称为值（value），字典中各元素的键都只能是字符串、元组或数字，不能是列表（列表时可变的）。字典是任何数据类型可变的无序集合，键值必须唯一不可变。

 1、使用 { } 创建字典：

d = { key1 : value1, key2 : value2...}

# 根据同学的名字查找对应的成绩
score = {'Mike': 95, 'Nancy': 85, 'Helen': 89, 'John':65, 'Sarah':100}

2、通过 fromkeys() 方法创建字典

# 使用fromkeys()方法创建带有默认值的字典

d = dict.fromkeys(list, value = None)

实例练习：

3、通过 dict() 映射函数创建字典

# 字符串键值对，字符串不能带引号
a1= dict(str1=value1, str2=value2, str3=value3)

# dict()函数传入列表或元组
#方式1
demo = [('abc',1), ('cde',2), ('efg',3)]
#方式2
demo = [['abc',2], ['cde',1], ['efg',3]]
#方式3
demo = (('abc',2), ('cde',1), ('efg',3))
#方式4
demo = (['abc',2], ['cde',1], ['efg',3])
a2= dict(demo)

# 通过dict()函数和zip()函数，两个列表转换为对应的字典
keys =['abc', 'cde', 'efg']
values = [1,2,3]
a3 = dict(zip(keys, values))

4、访问字典

# Python中访问字典元素的格式为：
dict[key]

实例练习：

 若键值不存在，则会抛出异常提示，如图：

5、通过使用 get() 方法来获取指定键对应的值，当指定的键不存在时，get()方法不会抛出异常。

dict.get(key[,default])

实例练习：

若 get() 方法返回的是空值，则显示None

 6、删除字典dict，可以使用 del 关键字删除字典

实例：

 图中的del操作后，引发异常提示，del 删除后该score字典不再存在了。

7、dict 字典基本操作（添加、修改、删除键值对）

7.1 添加键值对

dict[key] = value

实例：

7.2 修改键值对，字典中键（key）不能被修改，只能修改值（value），新添加的键与已存在的键相同，那么所对应的键的值就会被新的值所替换。

实例：

比较 dict[key] 和 dict.setdefault(key, default =None)区别：

dict[key]会把之前key对应的值修改掉，而dict.setdefault(key, default =None)不会修改键之前的对应的值（添加学生信息，一般使用setdefault来添加信息）

dict.setdefault(key, default=None)

7.3 删除键值对，用 del 语句删除键值对

实例：

7.4、判断字典中是否存在指定键值对：首先判断字典中是否有对应的键值对，可以使用 in 或 not in 运算符。

8、字典数据类型为 dict ，该类型的基本方法

8.1 dict.keys() 方法：以列表返回一个字典所有的值

　  dict.values() 方法：以列表返回字典中所有值

8.2 dict.items() 方法：以列表返回可遍历的（键、值）元组数组

实例中包含key()、value()、items()：

输出结果中，在 Python 2.x 中，上面三个方法的返回值都是列表（list）类型。但在 Python 3.x 中，它们的返回值并不是我们常见的列表或者元组类型，因为 Python 3.x 不希望用户直接操作这几个方法的返回值。

python 3.X中一般返回的数据方法为：list() 函数 和 for in 循环变量它们的返回值

（1）list() 函数实例：

 （2）for in 循环遍历

8.3 dict.clear() ：删除字典内所有元素

8.4 dict.copy() ：返回一个字典的浅复制

实例如图：copy()  方法将字典score 的数据全部拷贝给了字典score1

8.5 dict.get(key,default=None)：返回指定键的值，如果值不存在返回default默认的None值：

（1）dict.get()

 （2）dict[]和dict.(key,default=None)qq区别：

8.6 dict.has_key(key)：若键在字典返回True，反之返回False   （Python 2.X函数使用方法）

      Python 3.X的使用方法为：

score = {'Mike': 95, 'Nancy': 85, 'Helen': 89, 'John':65, 'Sarah':100, 'Tom':77}
# score.has_key('Mike')  python2的函数
print(score.__contains__('Mike'))   # Python 3 的函数使用

8.7 dict.setdefault(key,default = None)：与get()方法类似，若键不存在字典中，将会添加键并将值设为指定值默认None

　　get() 和 setdefault() 区别在于：当指定的键不存在时，setdefault() 可以通过增加键值对来更新字典。

8.8 dict.update(dic2)：字典dict2的键值对更新到dict里

 实例中，update()操作如图

8.9 dict.pop(key[,default])：删除字典给定的键对应的值，返回值为被删除的值。

（1）dict.popitem() ：返回并删除字典中最后一对键值对

实例中，pop() 和 popitem() 删除操作

 （2）del d[ key] 和 dict.pop(key)删除不存在的key时：

 

8.10 dict.fromkeys(seq[,val])：创建一个新字典，四五千中元素做字典的值，val为字典所有键对应的初始值

9.利用字典判断字典里面的值存不存在

users ={
    'Amy': '123456',
    'Bob': '456789',
    'Mike': '147258'
}
username = 'Amy'
# print(username in users.keys())
# print(username in users)  # 推荐使用这个，判断Key是否存在
# users.has_key(username)   # python2 方法
print(users.items())      # 循环遍历字典，以列表方式展示
for k,v in users.items():
    print(k,v)
for k in users:
    print(k,users.get(k))   # 推荐循环字典操作

字典练习：注册用户，用户名，密码，确认密码，最多输入3次，超过3次提示错误次数超限，账号密码不能为空，两次输入密码是否一致，输入的用户是否存在

users = {
    'Amy':'123456',
     'Bob': '456789',
    'Mike':'147258'
}
for i in range(3):
    username = input('用户名：').strip()
    password = input('密码：').strip()
    cpwd = input('再次确认密码：').strip()
    if username == '' or password =='' or cpwd == '':
        print('账号或密码不能为空！')
    elif password != cpwd:
        print('两次输入的密码不一致！')
    elif username in users:
        print('用户名已存在！')
    else:
        users[username] = password
        print('注册成功！')
        break
else:
    print('错误次数过多！')
print(users)

（二）list字典嵌套

实例：字典里嵌套字典，字典里面嵌套list

info = {
    'Amy':{
        'age':18,
        'addr':'beijing',
        'tel':'18801124520',
        'hobby':['reading', 'running', 'playing tennis']
    },
    'Nick':{
        'age':20,
        'addr':'tianjin',
        'tel':1302254850,
        'hobby':['movies', 'cooking', 'playing badminton']
    }

}
# Amy hobby中不喜欢running了，喜欢上了art
# Nick Tel 手机变成了：15055001550

info['Amy']['hobby'].remove('running')
info['Amy']['hobby'].append('art')
info['Nick']['tel']=(15055001550)
print(info)

（三）元组（tuple）：元组的元素不能修改

1、元组、列表、字典表示方式：

# 元组用小括号（）
a = (1,2,3,4,5)

# 列表用方括号[]
b = [1,2,3,4,5]

# 字典用花括号{}
c = {key:value}

2、元组和列表（list）的不同之处在于：

• 列表的元素是可以修改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 元组一旦被创建，其元素不可修改，故元组是不可变序列。通常情况下，用于保存无需修改的内容。

3、创建元组

（1）使用（）直接创建元组

# 创建元组
tuple = (a1,a2,a3,..,n)

       若元组中只包含一个元素时，需要在元素后面添加逗号，否则解释器会将它视为字符串：

# 元组中只包含一个元素时：
 tup1 = (a1,)

实例：

 # int float bool None list str dict tuple
n= (1,2,3,4,5) # 不可变的列表
 # 元组一旦被创建，不能改变里面的值
print(n[0])

（2）使用tuple()函数创建元组

　　  使用内置函数 tuple()

# data可以是字符串，元组，range对象转换为元组
tuple(data)

    #将字符串转换成元组
    tup1 = tuple("hello")
    print(tup1)
    #将列表转换成元组
    list1 = ['Python', 'Java', 'C++', 'JavaScript']
    tup2 = tuple(list1)
    print(tup2)
    #将字典转换成元组
    dict1 = {'a':100, 'b':42, 'c':9}
    tup3 = tuple(dict1)
    print(tup3)
    #将区间转换成元组
    range1 = range(1, 6)
    tup4 = tuple(range1)
    print(tup4)
    #创建空元组
    print(tuple())

4、元组的index()方法和count()方法

m = ('1245521.2555', 'admin', '1545646')
print(m.index('admin'))
print(m.count('admin'))

5、访问元组，可以使用索引index()访问元组中的某个元素，也可以使用切片访问元组

# 使用索引访问元组元素：
m = ('1245521.2555', 'admin', '1545646')
print(m[2])

# 使用切片访问元素
word=tuple('wearefamily')
print(word[2:5:1]))

6、修改元组：不可变序列，元组中元素不能被修改。只能创建新的元组替换旧的元组。

 
tup1 = (100, 55.26)
tup2 = ('hello', 'hi')
print(tup1)
print(tup2)
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

7、删除元组：可以通过del 关键字删除整个元组。

     实例如图：

（四）集合：是一个无序的不重复的元素序列，可以使用大括号 { } 或者 set() 函数创建集合，创建一个空集合必须用 函数 set() 不能用 { } (用{ }创建一个空字典)。

1、创建集合

# 创建集合

setname = {value1, value2, value3,...}

# 使用 set() 函数
setname = set(vlaue)

2、访问set集合元素：使用循环结构，逐一读取数据。

a = {1,2,3,4,5,6,7,8,9}
for b in a:
    print(b,end=' ')

3、删除 set 集合，使用 del() 语句

a = {1,2,3,4,5,6,7,8,9}
print(a)
del(a)
print(a)

4、集合中，添加元素

（1）使用 add() 方法

注意：使用add()方法添加元素，若元素已存在则不进行该添加操作，只能添加数字、字符串、元组或布尔类型，不能添加列表、字典、集合可变数据，否则会报错，例如：TypeError: unhashable type: 'list'

# 集合中添加元素
setname.add(x)
# 例如：
a = {1,2,3,4,5}
a.add((1,2))
print(a)

（2）还可以使用 update() 方法，且参数可以是列表、元组、字典

# 添加元素，使用 update() 方法
a = {1,2,3,4,5,6,7,8,9}
print(a)
a.update(['ab','bc'])
print(a)

5、集合中删除元素

（1）可以使用remove()  方法，若元素不存在，则会发生错误，例如：KeyError: 'a'

# 移除集合中的元素，使用remove()
setname.remove()

a = {1,2,3,4,5,6,7,8,9}
print(a)
a.remove(1)
print(a

（2）移除集合中的元素，使用 discard() 若元素不存在，不会发生错误

# 移除集合中的元素，使用 discard() 方法

a = {1,2,3,4,5,6,7,8,9}
print(a)
a.discard('a')
print(a)

（3）随机删除集合中的一个元素

# 使用 pop() 方法随机删除
a = {1,2,3,4,5,6,7,8,9}
print(a)
print(a.pop( ))

（五）字符串常用方法

s = '  abcdefgABCDEabcdefg  '
# 常用的字符串方法
# s.count('a')    # 统计字符串出现的次数
# print(s.count('a'))

# s.index('a')     # 检索是否包含指定的字符串，不存在抛出异常:ueError: substring not found
# print(s.index('b'))
# print(s.find('b')) # 检索字符串中是否包含目标字符串，不存在会抛出异常,以：-1 返回

# s.strip()       # 删除字符串前后（左右两侧）的空格或特殊字符
# print(s.strip())
# s.lstrip()      # 删除字符串前面（左边）的空格或特殊字符
# print(s.lstrip())
# s.rstrip()      # 删除字符串后面（右边）的空格或特殊字符
# print(s.rstrip())

# s.replace()     # 把字符串中的 old（旧字符串） 替换成 new(新字符串)
# print(s.replace('a','A',1))  # (将被替换的子字符串,新字符串,替换次数）

# s.format()      # 字符串格式化
# print("{} {}".format("hello", "world") ) # 不设置指定位置，按默认顺序
# print("{0} {1}".format("hello", "world") ) # 设置指定位置
# print( "{1} {0} {1}".format("hello", "world"))  # 设置指定位置

# s.upper()
# print(s.upper())                         # 将字符串中的小写字母转为大写字母

# # s.lower()                              # 将字符串中的大写字母转为小写字母
# print(s.lower())

# s.zfill()                                # 返回指定长度的字符串，原字符串右对齐，前面填充0
# s1= '12'
# print(s1.zfill(3))

# s.isdigit()                              # 判断是否为纯数字
# s2 = '1.23'
# print(s2.isdigit())

# s.endswith()                             # 判断字符串是否以指定后缀结尾
# print(s.endswith(','))
# s.startswith()                           # 判断是否以指定字符串开头
# print(s.startswith(' '))

# 用的比较少些
# s.format_map()                            # 字典字符串
# print('{name},{value}'.format_map({"name":"Amy","value":250}))

# s.center()                               # 字符串居中
# print('欢迎登陆'.center(50,'*'))
# print('登陆结束'.center(50,'*'))

# s.title()                        # 返回"标题化"的字符串,所有单词都是以大写开始，其余字母均为小写
# print('hello world'.title())

# s.isspace()                     # 判断字符串是否含有空格
# print('   '.isspace())

# s.isupper()                    # 判断字符串中所有的字母是否都为大写
# print(s.isupper())

# s.islower()                    # 判断字符串中所有的字母是否都为小写
# print(s.islower())

# s.capitalize()                 # 将字符串的第一个字母变成大写,其他字母变小写
# print('hello world'.capitalize())

# 重要的
# s.split()                     # 分隔字符串
# s2 = '''hello
# nihao
# hi
# good
# bad
# worse'''
# print(s2.split('
'))
# print(s2.split('#'))  # 以不存在的分隔符进行分隔，分隔不了把原来的字符串放在list中，不报错

# s.join()              # 将序列中的元素以指定的字符连接生成一个新的字符串
# l = ['art', 'English', 'Math', 'Chinese', 'Music']
# l_str =' '.join(l)
# print(l_str)
# print(type(l_str))

（六）切片：是list范围取值的一种方式

import string
# print(string.ascii_lowercase)
# print(string.ascii_uppercase)
# print(string.digits)
# print(string.ascii_letters)
# print(string.punctuation)
#     0    1    2    3    4    5    6    7    8    9    10   11   12   13
l = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n']
#    -14  -13   -12  -11  -10   -9  -8   -7    -6  -5   -4    -3    -2   -1
print(l[2:10])
print(l[2:])     # 取值到末尾
print((l[:5]))    # 从最前面取值
print(l[:])       # 取所有的元素
print(l[0:10:1])   # 从最前面开始，取值到第10个，步长为1
# 切片的时候顾头不顾尾的
print(l[::-1])      # 取所有的元素，步长为负数时，取值范围就要从右往左开始取，同时开始和结束下标也要写成负数

（七）深拷贝和浅拷贝

1、copy.copy() 浅拷贝只拷贝父对象，不会拷贝对象的内部的子对象；

2、copy.deepcopy() 深拷贝，只拷贝对象及其子对象

3、拷贝对象是个一维列表，浅拷贝和深拷贝没有区别，均是重新申请一个新的内存地址；

4、嵌套列表、字典嵌套列表，深拷贝和浅拷贝完全不同。

（1）列表：进行浅拷贝和深拷贝

# 浅拷贝
import copy
# 定义一个列表，其中一个元素是可变类型
list1 = [[1,2], 'sun', 55]
print(list1)
# 进行浅拷贝
list2 = copy.copy(list1)
print(list2)
# # 查看对象地址是否相同(答案是结果是不同的)
print(id(list1))
print(id(list2))
# # 查看第一个元素地址是否相同（答案是结果是相同的）
print(id(list1[0]))
print(id(list2[0]))
# 查看第二个元素地址是否相同（答案是结果是相同的）
print(id(list1[1]))
print(id(list2[1]))
# 改变第一个值，查看复制对象变化  (结果复制对象发生变化)
list1[0][0] = 2
print(list1)
print(list2)
# 改变第二个值，查看复制对象变化（复制对象没有发生变化）
list1[1] = 'moon'
print(list1)
print(list2)

# 深拷贝
import copy
# 定义一个列表，其中一个元素是可变类型
list1 = [[1,2], 'sun', 55]
print(list1)
# 进行深拷贝
list2 = copy.deepcopy(list1)
print(list2)
# 查看对象地址是否相同(结果是不同的)
print(id(list1))
print(id(list2))
# 查看第一个元素地址是否相同（结果是不同的）
print(id(list1[0]))
print(id(list2[0]))
# 查看第二个元素地址是否相同（答案是结果是相同的）
print(id(list1[1]))
print(id(list2[1]))
# # 改变第一个值，查看复制对象变化  (复制对象没有发生变化)
list1[0][0] = 2
print(list1)
print(list2)
# 改变第二个值，查看复制对象变化（复制对象没有发生变化）
list1[1] = 'moon'
print(list1)
print(list2)

 （2）字典：进行浅拷贝和深拷贝

import copy
a = {1:[1,2,3]}             # 原始对象
b = a                      # 赋值，穿对象的引用
c= copy.copy(a)            # 浅拷贝
d = copy.deepcopy(a)       # 深拷贝
print(a)
print(b)
print(c)
print(d)
a[1].append(4)             # 修改对象a的list
print(a)
print(b)
print(c)
print(d)

（八）非空即真，非0即真

# None {} () [] ''
# True False
# username =input('username:')
# password =input('password:')
# if username.strip():
#     print('你输入的不为空',username)
# else:
#     print('username不能为空')

（九）操作文件

1、绝对路径和相对路径

（1）绝对路径：从根文件夹开始，Windows系统以（C: 或D:）作为根文件夹；OS系统或者Linux系统以 / 作为根文件夹。

（2）相对路径：指文件相对于当前工作目录所在的位置。

2、打开文件：open(文件路径和文件名，打开模式)

（1）绝对路径的打开方式

#Windows 系统
open(r'D:userXXXa.txt')

# OS或Linux系统
open('/XXX/XXX/a.txt')

注：“r”表示字符串中的转义字符不进行转义。

（2）打开模式分别为：r、w、a、r+、w+、a+、x、b、t、+

r：只读模式，如果文件不存在，返回异常FileNotFoundError，默认值；只能读不能写，写入的时候报错：            　　　　             io.UnsupportedOperation: not writable

r+：打开不存在的文件报错：FileNotFoundError

w：覆盖写模式，文件不存在则创建一个文件，存在则完全覆盖源文件；只能写，不可读报错：

     io.UnsupportedOperation: not readable

w+：都会清空文件

a：追加写模式，文件不存在则创建一个文件，存在则在原文件最后追加内容；只能写，不可读，报错：io.UnsupportedOperation: not readable

a+：追加文件，可读，但读不到内容

b：二进制文件模式

t：文本文件模式，默认值

+：与r/w/x/a一同使用，在原功能基础上增加同时读写功能

3、读取文件内容：read()

(1)打开文件，进行读取文件，当文件中含有中文时，报错：UnicodeDecodeError，这是需要加上字符集：encoding='utf-8'

# r：只读模式
f = open('a.txt', 'r',encoding='utf-8')
result = f.read()
print(result)

（2）读取的文件不存在时，报错：FileNotFoundError

（3）read()、readline()和readlines()的区别

•  f.read()：从文件中读取整个文件内容，结果是一个字符串；

• f.readline()：从文件中读取一行内容，结果是一个字符串

• f.readlines：从文件中读取所有行，以每行元素组成一个列表；

•  read和reline操作在文件的读取时，会记录上次读取的位置，继续往下读取，而readlines是将原来的文件的最初的每一行   内容输出为列表。

4、写入文件内容：write()

（1）向文件写入字符串S，每次写入后，记录写一个写入指针。

（2）写入文件，write() 不能以列表写入，必须是字符串，否则报错：TypeError: write() argument must be str, not list

 （3）写入文件，writelines()可以以列表写入文件里面

 注意：writelines()其实封装write()字符串类型，不能是整型

（4）write()写完之后，输出返回值为None

（5）写入内容需要换行展示：' '.join()

 （6）将int类型转换string类型写入

5、文件指针：记录文件读取到哪一行

（1）seek() 函数：改变当前文件操作指针的位置，0代表文件开头，2代表文件结尾。

file.seek(放置位置，偏移量)

 （2）清空文件内容后，添加修改内容

实例1：

 实例2：

 

6、关闭文件

变量名.close()