• 三、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()
    温故而知新
  • 相关阅读:
    删除Rancher节点的正确姿势
    go深度拷贝json版
    go深度拷贝gob版
    视频摘要视频浓缩
    教你如何用Jenkins自动化部署项目(教程,从零到搭建完成)
    EXCEL2010中如何使用数据透视表
    安装window下的redis,redis可视化管理工具(Redis Desktop Manager)安装,基础使用,实例化项目
    什么是CMOS与BIOS?又有什么区别?
    Linux下面写Tomcat重启脚本
    平凡变成非凡
  • 原文地址:https://www.cnblogs.com/krystal-xiao/p/13516333.html
Copyright © 2020-2023  润新知