• Python之基本数据类型及内置方法


    Python之基本数据类型及内置方法

    数字类型

    整型

    1.作用

    年龄/id
    

    2.定义方式

    x = 10
    

    3.使用方法

    + - * / % // ** < <= > >= == !=
    

    4.有序or无序

    有索引的就有序,无索引的就无序

    压根就没有有序无序一说
    

    5. 可变or不可变

    值变id不变叫可变,值不变id变叫不可变

    整型不可变
    
    x = 10
    print(id(x))
    x += 1
    print(id(x))
    

    浮点型

    1.作用

     薪资
    

    2.定义方式

    x = 10.1
    

    3.使用方法

    + - * / % // ** > >= < <= == !=
    

    4.有序or无序

    压根没有有序无序一说
    

    5. 可变or不可变

    不可变      
    
    x = 10.1
    print(id(x))
    x +=1
    print(id(x))
    

    字符串类型

    1.作用

    姓名
    

    2.定义方式

    单引号/双引号/三单引号/三双引号
    

    3.使用方法

    # 优先掌握
    
    # 左    右
    s='nick handsome'
    #  0123
    
    # 索引
    print(s[1])
    
    #索引切片
    print(s[0:4])  # 顾头不顾尾
    print(s[0:4:2])  # 2表示步长,隔一个取一个
    print(1, s[4:0:-1])  # +从左到右,-表示从右到左
    print(1, s[2:])  # 左边的不写取到最左边,右边的不写取到最右边
    
    #for循环
    for i in s:
        print(4, i)
    
    #成员运算
    print('nick' in s)
    print('nick1' not in s)  # True
    
    #strip()  默认去除两端空格,可以指定去除的字符,可以指定多个字符同时去掉
    s1 = 'a  nick   ******'
    print(s1.strip(' kc*'))  # 可以乱序,但是不能没有
    
    #split() # 切割
    s2 = 'nick|123658|180|140'
    print(s2.split('|'))  # 按照|切割字符串,得到的是一个列表
    
    #len()长度
    s1 = 'nick handsome'
    print(len(s1))
    
    # 掌握
    
    # lstrip&rstrip
    s3 = '**nick**'
    print(s3.lstrip('*'))
    print(s3.rstrip('*'))
    
    # lower&upper
    s3 = 'Nick'
    print(s3.lower())  # 小写
    print(s3.upper())  # 大写
    
    # startswith&endswith
    s4 = 'nick handsome'
    print(s4.startswith('nick'))  # 以。。。开始
    print(s4.endswith('some'))  # 以。。。结束
    
    # rsplit
    s = 'nick|handsome|180|140|'
    #    01234
    # print('range(len(s))',range(len(s)))
    # lt = []
    # ind = -1
    # for i in range(len(s)):
    #     if s[i] == '|':
    #         lt.append(s[ind+1:i])
    #         ind = i # ind = 4
    #
    # print('lt', lt)
    
    print(s.split('|',1))
    print(s.rsplit('|',1))  # 从右切割
    
    # join
    s = 'nick|handsome|180|140'
    lt = s.split('|')
    print(lt)
    # 用*拼接列表内的每一个元素
    # new_s = ''
    # for i in lt:
    #     i += '*'
    #     new_s += i
    # print(new_s)
    print('*'.join(lt))  # 使用*拼接列表内的每一个元素
    
    # replace
    s = 'nick handsome'
    s = s.replace('nick','nick chen')
    print(s)
    
    # isdigit/isalpha
    s = 'a123123'
    print(s.isdigit())  # 判断字符串内字符是否都为数字
    s = 'askdlfj234'
    print(s.isalpha())
    # pwd = input('请输入你的密码:')
    # if not pwd.isdigit():
    #     print('请输入纯数字')
    
    ## 了解
    
    # find|rfind|index|rindex|count
    s = 'nick handsome'
    print(s.find('h'))  # 找索引,-1表示没找到
    print(s.rfind('h',6,10))
    
    print(s.index('h'))
    # print(s.index('sadf'))  # 找不到报错
    # print(s.find('sadf'))  # 找不到返回-1
    
    s = 'aaaaacccc'
    print(s.count('a'))
    
    # center|ljust|rjust|zfill
    s = 'nick'
    print(s.center(50,'*')) # 居中
    print(s.ljust(50,'*'))
    print(s.rjust(50,'*'))
    s = '111'
    print(s.zfill(8))
    
    # expandtabs
    # 
     换行
    # 	 缩进
    s = 'a				a'
    print(s)
    print(s.expandtabs(18))
    
    # captalize|swapcase|title
    s = 'nickNick handsome'
    print(s.capitalize())  # 首字母大写
    print(s.swapcase())
    print(s.title())  # 每个单词的首字母大写
    
    
    # is系列
    

    4.有序or无序

    有序
    

    5. 可变or不可变

    不可变
    s = 'nick'
    print(id(s))
    s += 'nick'
    print(id(s))
    
    

    列表

    1.作用

    存储多个值
    
    

    2.定义方式

    []用逗号隔开多个元素
    
    

    3.使用方法

    # 优先掌握
    
    # 1. 索引取值/索引修改值
    lt = [1, 2, 3, 4]
    print(lt[1])
    # lt[1] = 3
    # print(lt)
    
    # 2. 切片
    print(lt[:])
    print(lt[1:2])
    print(lt[1:4:2])
    
    # 3. for循环
    for i in lt:
        print(i ** 2)
    
    # 4. 成员运算
    print(1 in lt)
    print(5 in lt)
    
    # 5. len
    print(len(lt))
    
    # 6. append()
    lt.append(5)
    print(lt)
    
    # 7. del删除
    print(lt)
    # del lt[0]
    # print(lt)
    
    
    # insert
    lt = [1, 2, 3, 4, 5]
    lt.insert(0, 0)  # 往前插入
    print(lt)
    
    # pop:按照索引删除值
    lt = [11, 22, 33, 44, 55]
    lt.pop(0)
    print(lt)
    
    # remove:按照值删除值
    lt.remove(22)
    print(lt)
    
    # count:计数
    lt = [11, 11, 11, 22]
    print(lt.count(11))
    
    # index:寻找值的索引
    print(lt.index(11))  # 找到了就返回
    
    # clear:清空列表
    lt = [1, 2, 2, 3]
    lt.clear()
    print(lt)
    
    # copy:拷贝列表
    lt = [1, 2, 3, 4]
    lt1 = lt.copy()
    print(lt1)
    
    # extend: 扩展列表
    lt1 = [1, 2, 34]
    lt2 = [1, 1, 2, ]
    
    lt1.extend(lt2)
    print(lt1)
    
    # reverse:反转列表
    lt = [1, 2, 3, 4]
    lt.reverse()
    print(lt)
    
    # sort
    lt = [2, 3, 1, 0, 4]
    lt.sort(reverse=True)
    print(lt)
    
    

    4.有序or无序

    有序
    
    

    5. 可变or不可变

    可变
    
    lt = [1, 2, 3]
    print(id(lt))
    lt.append(4)
    print(id(lt))
    
    

    元组

    只可取不佳而更改的列表

    1.作用

    # 元组一创建就被写死了, 定义元组--》占用内存小 --》 写死了
    
    

    2.定义方法

    ()内用逗号隔开多个元素
    # lt =list([1,2,3])
    tup = tuple((1, 2, 3))
    print(tup, type(tup))
    
    # 如果元组只有一个元素,必须得加逗号
    tup1 = (1,)
    print(tup1, type(tup1))
    
    

    3.使用方法

    # 1. 索引取值
    print(tup[0])
    # 2. 索引切片
    print(tup[0:3])
    # 3. for循环
    for i in tup:
        print(i)
    # 4. 成员运算
    print(0 in tup)
    # 5. len长度
    print(len(tup))
    # 6. index获取元素索引
    print(tup.index(1))
    # 7. count 计数
    print(tup.count(2))
    
    

    4. 有序or无序

    有序
    
    

    5. 可变or不可变

    压根不存这一说
    
    

    字典

    1.作用

     存储多个数据,对每个数据具有描述
    
    

    2.定义方法

    {}内用逗号隔开多个键key(具有描述意义,不能为可变数据类型):值value(任意数据类型)对  # 散列表(哈希表)
    
    dic = {'name': 1}
    print(dic)
    
    # 0001
    dic = {0: '功能1', 1: '功能2'}
    print(dic)
    
    dic = {[1, 2]: 'a'}  # 可变==不可哈希,不可变==可哈希
    print(dic)
    
    

    3.使用方法

    # 优先掌握
    # 1. 按key取值/按key修改值
    dic = {'a': 1, 'b': 2, 'c': 3}
    
    print(dic['a'])
    
    dic['b'] = 4
    
    print(dic)
    
    # 2. 添加值,没有就添加,有就修改
    dic['d'] = 4
    print(dic)
    
    # 3. for循环
    for i in dic:
        print(i)
    
    # 4. 成员运算
    print('a' in dic)
    
    # 5. len长度
    print(len(dic))
    
    # 6. keys/values/items
    print(dic.keys())  # 看成列表
    print(dic.values())  # 获取所有值
    
    print(dic.items())
    for i in dic.items():
        print(i)
    for kasdfsad, vsdfsdf in dic.items():  # 解压缩
        print(kasdfsad, vsdfsdf)
    
    # 掌握
    
    # get:获取
    s = 'e'
    # print(dic[s])  # KeyError: Nonetype --> s是None,并不是你想象的e
    print(dic.get('b', 1))  # 字典中没有返回None,可以给定一个默认值
    
    # update : 更新,等同于list里的extend
    dic1 = {'a': 1, 'c': 2}
    dic2 = {'b': 1, 'd': 2}
    dic1.update(dic2)
    print(dic1)
    
    # fromkeys
    print(dict.fromkeys(dict.fromkeys([1, 2, 3, 4])))  # 默认给None
    
    # setdefault  # 字典有这个key,就不修改,没有则增加
    dic.setdefault('j', 2)
    dic.setdefault('a', 2)
    print(dic)
    
    

    4. 有序or无序

    无序
    
    

    5. 可变or不可变

    可变
    
    

    散列表(哈希表)

    # 散列表/哈希表存储数据 --》 相比较列表,插入/删除数据更快
    
    # 1. 首先对key做了哈希处理(能对所有数据类型都可以哈希处理):梅森旋转算法(生成伪随机数)--> 通过哈希处理对于每个key他都可以生成一个序列(永不重复,相同的东西进入哈希处理,结果相同)
    
    import hashlib
    
    m = hashlib.md5()
    # m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
    # m.update(b'b')  # 92eb5ffee6ae2fec3ad71c777531578f
    # m.update(b'c')  # 4a8a08f09d37b73795649038408b5f33
    # m.update(b'd')  # 8277e0910d750195b448797616e091ad
    m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
    print(m.hexdigest())
    
    
    
    # 2. 使用哈希函数对刚刚生成的序列(纯数字),对纯数字除9取余(0,1,2,3,4,5,6,7,8)
    
    
    ''' 
    key 哈希处理 纯数字序列 哈希函数  哈希值
    'a' --》     12          --》     3
    'b' --》     14          --》     5
    'c' --》     24          --》     6
    'd' --》     21          --》     3
    '''
    
    
    # 1. 为什么key是不可变数据类型
    dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    # dic['a']
    
    # 2. 为什么key不能重名
    dic = {'a':1, 'a':2}  # key不能重名
    print(dic['a'])
    
    
    # 3. 字典为什么是乱序的
    
    
    # 4. 散列表(哈希表)解决了什么问题
    
    

    集合

    交集/并集/补集/差集 
    ∩ ∪
    
    

    1.作用

     1。进行上述运算 2. 去重 3.乱序 ---》基于散列表实现的
    
    

    2.定义方法

    {}内以逗号隔开多个元素(不能可为变数据类型)
    
    
    # s = {}  # 空字典
    print(type(s))
    # s = set()  # 空集合  # 上面定义了一个相同的变量但是从未使用,你又定义了这个变量
    print(type(s))
    
    # inp = input('enter')
    # s = {}
    # if inp > '11':  # 字符串比较,先比较第一位数字,然后再比较第二位数字
    #     s +=1
    # else:
    #     print(s)
    
    s = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6}  # 对于数字而言,不会乱序;但是对于其他,就乱序
    print(s)
    
    

    3.使用方法

    # 1.合集(|):求两个用户所有的好友(重复好友只留一个)
    >>> friends1 | friends2
    {'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
    
    # 2.交集(&):求两个用户的共同好友
    >>> friends1 & friends2
    {'jason', 'egon'}
    
    # 3.差集(-):
    >>> friends1 - friends2 # 求用户1独有的好友
    {'kevin', 'zero'}
    >>> friends2 - friends1 # 求用户2独有的好友
    {'ricky', 'Jy'}
    
    # 4.对称差集(^) # 求两个用户独有的好友们(即去掉共有的好友)
    >>> friends1 ^ friends2
    {'kevin', 'zero', 'ricky', 'Jy'}
    
    # 5.值是否相等(==)
    >>> friends1 == friends2
    False
    
    # 6.父集:一个集合是否包含另外一个集合
    # 6.1 包含则返回True
    >>> {1,2,3} > {1,2}
    True
    >>> {1,2,3} >= {1,2}
    True
    # 6.2 不存在包含关系,则返回True
    >>> {1,2,3} > {1,3,4,5}
    False
    >>> {1,2,3} >= {1,3,4,5}
    False
    
    
    # 7.子集
    >>> {1,2} < {1,2,3}
    True
    >>> {1,2} <= {1,2,3}
    True
    
    
    # add(*******)
    pythoners.add('oscar')
    print(pythoners)
    
    # pythoners.remove('oscar1')  # 没有报错
    # print(pythoners)
    # pythoners.discard('oscar1')  # 没有不报错
    # print(pythoners)
    
    pythoners.pop()  # 随机删除一个
    print(pythoners)
    
    
    # 去重(有局限性)
    # 1. 只能针对不可变类型
    # 2. 集合本身是无序的,去重之后无法保留原来的顺序
    
    >>> l=['a','b',1,'a','a']
    >>> s=set(l)
    >>> s # 将列表转成了集合
    {'b', 'a', 1}
    >>> l_new=list(s) # 再将集合转回列表
    >>> l_new
    ['b', 'a', 1] # 去除了重复,但是打乱了顺序
    
    # 针对不可变类型,并且保证顺序则需要我们自己写代码实现,例如
    l=[
        {'name':'lili','age':18,'sex':'male'},
        {'name':'jack','age':73,'sex':'male'},
        {'name':'tom','age':20,'sex':'female'},
        {'name':'lili','age':18,'sex':'male'},
        {'name':'lili','age':18,'sex':'male'},
    ]
    
    new_l=[]
    
    for dic in l:
        if dic not in new_l:
            new_l.append(dic)
    
    print(new_l)
    # 结果:既去除了重复,又保证了顺序,而且是针对不可变类型的去重
    [
        {'age': 18, 'sex': 'male', 'name': 'lili'}, 
        {'age': 73, 'sex': 'male', 'name': 'jack'}, 
        {'age': 20, 'sex': 'female', 'name': 'tom'}
    ]
    
    
    
    
    # 1.长度
    >>> s={'a','b','c'}
    >>> len(s)
    3
    
    # 2.成员运算
    >>> 'c' in s
    True
    
    # 3.循环
    >>> for item in s:
    ...     print(item)
    ... 
    c
    a
    b
    
    
    

    4. 有序or无序

    无序
    
    

    5. 可变or不可变

    可变  
    set = {1, 2, 3}
    print(id(set))
    set.add(4)
    print(id(set))
    
    

    数据类型总结

    存值个数

    # 存一个值:整型/浮点型/字符串
    # 存多个值:列表/元组/字典/集合
    
    

    有序和无序

    # 有序:字符串/列表/元组(序列类型)
    # 无序:字典/集合
    
    

    可变or不可变

    可变数据类型: 值发生改变时,内存地址不变,即id不变,证明在改变原值
    不可变类型: 值发生改变时,内存地址也发生改变,即id也变,证明是没有在改变原值,是产生了新的值

    # 可变:列表/字典/集合
    # 不可变:整型/浮点型/字符串/元组
    
    
  • 相关阅读:
    《软件工程课程总结》
    课后作业-阅读任务-阅读笔记-4
    两个不同的网络,进行数据同步的设计思路
    IDEA清理缓存项目
    IDEA快捷键
    IDEA如何添加多个maven项目工程
    sqlserver数据库中的mdf文件太大,表空间分析和表空间释放
    关于AOP的面向切面编程
    关于.net进行爬虫
    关于调用别人接口的一些问题总结
  • 原文地址:https://www.cnblogs.com/jzm1201/p/12590499.html
Copyright © 2020-2023  润新知