• python数据类型


     

    什么是数据类型?

    计算机不能区分数字和字符的区别,需要我们去告诉他,于是就有了数据类型

    数字

    int(整型)

    在64位系统上,整数的位数为64位,取值范围为2^63~2^63-1,即-9223372036854775808~9223372036854775807

    >>> a = 2**64
    >>> type(a)
    <class 'int'>
    >>> b = 2**60
    >>> type(b)
    <class 'int'>

    bool()

    >>>bool()  # 无参数时返回False
    False
    >>> bool(0)  # 0是False
    False
    >>> bool(1)  
    True
    >>> bool(2)
    True
    >>> issubclass(bool, int)  # bool 是 int 子类
    True

    float (浮点型)

    即小数

    >>> n = 2.3
    >>> type(n)
    <class 'float'>

    字符串(str)

    定义

    字符串是一个有序的字符的集合,用于存储和表示基本的文本信息,在Python中,加了引号的字符都被认为是字符串!

    >>> name = "Alex Li" #双引号
    >>> age = "22"       #只要加引号就是字符串
    >>> age2 = 22          #int
    >>> 
    >>> msg = '''My name is Alex, I am 22 years old!'''  #3个引号也可以
    >>> 
    >>> hometown = 'ShanDong'   #单引号也可以

    在下面这种情况,使用单双引号

    msg = "My name is Alex , I'm 22 years old!"

    多行字符串必须用多引号

    msg = '''
    为你我受冷风吹
    
    寂寞时候流眼泪
    
    有人问我是与非 说是与非
    
    可是谁又真的关心谁
    
    若是爱已不可为
    
    你明白说吧无所谓
    
    不必给我安慰 何必怕我伤悲
    
    就当我从此收起真情 谁也不给
    '''
    print(msg)

    特性

    1. 按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序

    2. 可以进行切片操作

    3. 不可变,字符串是不可变的,不能像列表一样修改其中某个元素,所有对字符串的修改操作其实都是相当于生成了一份新数据。

    取消字符的特殊意义

    字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引号前面加

    >>> names = 'th
    th'
    >>> print(names)
    th
    th
    >>> names = r'th
    th'
    >>> print(names)
    th
    th

    简单拼接

    >>> name
    'Alex Li'
    >>> age
    '22'
    >>> 
    >>> name + age  #相加其实就是简单拼接
    'Alex Li22'
    >>> 
    >>> name * 10 #相乘其实就是复制自己多少次,再拼接在一起
    'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

    注意,字符串的拼接只能是双方都是字符串,不能跟数字或其它类型拼接

    >>> type(name),type(age2)
    (<type 'str'>, <type 'int'>)
    >>> 
    >>> name
    'Alex Li'
    >>> age2
    22
    >>> name + age2
    Traceback (most recent call last):
      File "", line 1, in 
    TypeError: cannot concatenate 'str' and 'int' objects
    # 错误提示数字 和 字符 不能拼接

    常用操作

    def capitalize(self):

    >>> name = 'aaaa'
    >>> name.capitalize()
    'Aaaa'
    # 首字母大写

    def casefold(self):

    >>> c = 'Alex Li'
    >>> c.casefold()
    'alex li'
    # 把字符串全变小写

    def center(self, width, fillchar=None):

    >>> c.center(50, "-")
    '---------------------Alex Li----------------------'
    # 居中显示,第一个数值表示宽度,第二个数值表示补充的字符

    def count(self, sub, start=None, end=None):

    >>> s = "welcome to apeland"  # 查找元素个数
    >>> s.count('e')  # 查找'e'个数
    3
    >>> s.count('e',3)  # 查找e个数,从下标为3的位置开始
    2
    >>> s.count('e',3,-1)  # 查找e个数,从下标为3的位置开始,到下标为-1时结束
    2

    def endswith(self, suffix, start=None, end=None):

    >> > s = "welcome to apeland"
    >> > s.endswith("land")  # 判断以什么结尾
    True

    def find(self, sub, start=None, end=None):

    >>> s = "welcome to apeland"
    >>> s.find('e')  # 找e,返回下标
    1
    >>> s.find('e',2)  # 从索引2开始找e
    6
    >>> s.find('e',7,-5)  # 在7和-5之间找e
    -1  # 没找到,返回-1

    def index(self, sub, start=None, end=None):

    >>> s = "welcome to apeland"
    >>> s.index('e')  # 找e,返回下标
    1
    >>> s.index('e',2)  # 从2开始,找e,返回下标
    6
    >>> s.index('e',7,-5)  # 在7和-5之间找e
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: substring not found  
    # 找不到抛出valueError异常

    def format(self, *args, **kwargs):

    >> > s = "Welcome {0} to Apeland,you are No.{1} user."
    >> > s.format("Eva", 9999)  # 第零个元素是对应{0},第一个元素是对应{1}
    'Welcome Eva to Apeland,you are No.9999 user.'
    
    >> > s1 = "Welcome {name} to Apeland,you are No.{user_num} user."
    >> > s1.format(name="Alex", user_num=999)  # 不用0、1,直接用=连接
    'Welcome Alex to Apeland,you are No.999 user.'
    
    # 类似占位符

    def isdigit(self):

    >>> num = '123'
    >>> num.isdigit()  # 判断是不是整数
    True  #是整数返回True
    >>> s = "welcome to apeland"
    >>> s.isdigit()
    False  # 不是整数返回False    
    >>> nume = '12.1'
    >>> nume.isdigit()
    False  # 小数也返回False
    
    # 需要用户输入整数时,先判断是否是整数,再把字符创强行转换成整型

    def islower(self):

    >>> s = "welcome to apeland"
    >>> s.islower()  # 判断都是小写
    True
    # 都是小写返回True,不都是返回False

    def isspace(self):

    >>> asd = ' '
    >>> asd.isspace()  # 判断是不是空格,只有空格才返回True
    True
    
    >>> asd = 'asd'
    >>> asd.isspace()
    False

    def isupper(self):

    >>> asd = 'ASD'
    >>> asd.isupper()  # 判断都是大写
    True  # 都是大写返回True
    
    >>> asd = 'asd'
    >>> asd.isupper()
    False

    def join(self, iterable):

    >>> n = ['alex','jack','rain']
    >>> '|'.join(n)  # 多个字符串用拼接起来,中间是“|”
    'alex|jack|rain'
    
    # 只能拼接字符串,不能拼接数字
    # 其中n = set 时,拼接key

    def ljust(self, width, fillchar=None):

    >>> asd = 'asd'
    >>> asd.ljust(10,'!')  # 从左开始数,数到 width,不够的在后面补 fillchar
    'asd!!!!!!!'

    def rjust(self, width, fillchar=None):

    >>> asd = 'asd'
    >>> asd.rjust(10,'!')  # 从右开始数,数到 width,不够的在前面补 fillchar
    '!!!!!!!asd'

    def lower(self):

    >>> asd = 'ASD'
    >>> asd.lower()  # 把所有字母变成小写
    'asd'

    def upper(self):

    >>> asd = 'asd'
    >>> asd.upper()  # 把所有字母改成大写
    'ASD'

    def strip(self, chars=None):

    >>> asd = '   
    asd	   '
    >>> asd.strip()  # 去掉两边的空格和
    ,	等
    'asd'

    def lstrip(self, chars=None):

    >>> asd = '   
    asd	   '
    >>> asd.lstrip()  # 去掉左边的空格和
    ,	等
    'asd	   '

    def rstrip(self, chars=None):

    >>> asd = '   
    asd	   '
    >>> asd.rstrip()  # 去掉右边的空格和
    ,	等
    '   
    asd'

    def replace(self, old, new, count=None):

    >>> asd = 'asd 120 , zxc 120 , qwe 20'
    >>> asd.replace('120','20')  # 把字符 120 替换成字符 20
    'asd 20 , zxc 20 , qwe 20'
    >>> asd.replace('20','120',2)  # 把字符20 替换成字符 120 ,而且替换次数不超过2
    'asd 1120 , zxc 1120 , qwe 20'

    def rsplit(self, sep=None, maxsplit=-1):

    >>> s
    'welcome to apeland'  
    >>> s.rsplit(' ')  # 以" "为分隔符,从右边开始分割
    # 如果是s.rsplit( ),则包含
    、	
    ['welcome', 'to', 'apeland']
    >>> s.rsplit('e')  # 以"e"为分隔符,从右边开始分割
    ['w', 'lcom', ' to ap', 'land']
    >>> s.rsplit('e',2)  # 以"e"为分隔符,从右边开始分割,分割2次
    ['welcom', ' to ap', 'land']

    def split(self, sep=None, maxsplit=-1):

    >>> s
    'welcome to apeland'
    >>> s.split('e',2)  # 从左边开始以e为分隔符开始切割,切割2次,即形成3个子字符串
    ['w', 'lcom', ' to apeland']

    def startswith(self, prefix, start=None, end=None):

    >>> s
    'welcome to apeland 
    asd	qwer'
    >>> s.startswith('st')  # 判断从 st 开始
    False
    >>> s.startswith('wel')  # 判断是从 wel 开始
    True
    >>> s.startswith('el',1)  #从 索引1 开始,判断是从 el 开始
    True

    def swapcase(self):

    >>> asd = 'aaAAaa'
    >>> asd.swapcase()  # 大小写互换
    'AAaaAA'

    def zfill(self, width):

    >>> aaa = 'aaa'
    >>> aaa.zfill(10)  # 指定宽度10,不够的用零补,补在前面
    '0000000aaa'

     列表(list)

    定义

    []内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素

    >>> na = [12,23,34,'asd']
    >>> na
    [12, 23, 34, 'asd']

    特点

    1.可存放多个值

    2.按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序

    3.可修改指定索引位置对应的值,可变

    列表的操作

    增加操作

    追加  

    >>> names
    ['alex', 'jack']
    >>> names.append("rain")  # 数据会追加到尾部
    >>> names.append("eva")
    >>> 
    >>> names
    ['alex', 'jack', 'rain', 'eva']

    插入

    >>> names.insert(2,"黑姑娘")  # 可插入任何位置
    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva']
    # 当要在最后个位置增加时,用append,因为insert会把原来位置的元素往后挤

    合并

    >>> n2 = ["狗蛋","绿毛"]
    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva']
    >>> names.extend(n2)  # 可以把另一外列表的值合并进来,()里面的拼接在最后
    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']

    列表嵌套

    >>> names.insert(2,[1,2,3])  # 把[1,2,3]插入到2位置
    >>> names 
    ['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
    >>> names[2][1]  # 访问到names的2位置,再在里面访问1
    2

    删除操作

    del删

    >>> names
    ['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
    >>> del names[2]  # 找到下标2的位置,删除它
    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']

    pop删

    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
    >>> names.pop()  # 默认删除最后一个元素并返回被删除的值
    '鸡头'
    >>> names
    ['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
    >>> help(names.pop)
    >>> names.pop(1)  # 删除指定元素
    'jack'
    # 删除之后返回删除的值

    清空

    >>> n2
    ['狗蛋', '绿毛', '鸡头']
    >>> n2.clear()  # 清空该列表里面的元素
    >>> n2
    []

    修改操作

    >>> names
    ['alex', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
    >>> names[0] = "金角大王"  # 修改0上面的元素
    >>> names[-1] = "银角大王"  # 修改-1上面的元素
    >>> names
    ['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王']

    查操作

    >>> names
    ['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
    >>> 
    >>> names.index("eva") # 返回从左开始匹配到的第一个eva的索引
    3
    >>> names.count("eva") # 返回eva的个数
    2

    切片

    >>> names
    ['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
    >>> names[1:4]  # 不包含下标4的元素
    ['黑姑娘', 'rain', 'eva']
    >>> names[-5:-1]  # 倒着切
    ['rain', 'eva', '狗蛋', '银角大王']
    
    >>> a
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> a[0:7:2]  # 设置步长为2
    [0, 2, 4, 6]

    列表反转

    >>> a[::-1]  # 通过把步长设置成负值,可达到列表返转的效果
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 
    >>> a[::-2]
    [9, 7, 5, 3, 1]
    
    # 同样,在字符串里面也适用
    >>> asd = 'asdfghjkl'
    >>> asd[ : :-1]
    'lkjhgfdsa'

    排序

    >>> a = [83,4,2,4,6,19,33,21]
    >>> a.sort()  # 排序
    >>> a
    [2, 4, 4, 6, 19, 21, 33, 83]
    >>> names=['金角大王', 'rain', '@', '黑姑娘', '狗蛋', "4","#",'银角大王', 'eva']
    >>> names.sort()  # 字符根据ASCII排序
    >>> names
    ['#', '4', '@', 'eva', 'rain', '狗蛋', '金角大王', '银角大王', '黑姑娘']

    反转

    >>> names
    ['#', '4', '@', 'eva', 'rain', '狗蛋', '金角大王', '银角大王', '黑姑娘']
    >>> names.reverse()  # 反转
    >>> names
    ['黑姑娘', '银角大王', '金角大王', '狗蛋', 'rain', 'eva', '@', '4', '#']

    循环列表

    >>> for i in names:  
    ...     print(i)
    ... 
    黑姑娘
    银角大王
    金角大王
    狗蛋
    rain
    eva
    @
    4
    #

     元组

    定义

    ()内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素

    特点

      1.可存放多个值

      2.不可变

      3._按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序

    创建

    ages = (11, 22, 33, 44, 55)
    #
    ages = tuple((11, 22, 33, 44, 55))

    常用操作

    #索引
    >>> ages = (11, 22, 33, 44, 55)
    >>> ages[0]
    11
    >>> ages[3]
    44
    >>> ages[-1]
    55
    #切片:同list  
    #循环
    >>> for age in ages:
        print(age)
    11
    22
    33
    44
    55
    #长度
    >>> len(ages)
    5
    #包含
    >>> 11 in ages
    True
    >>> 66 in ages
    False
    >>> 11 not in ages
    False

    注意

    元组本身不可变,如果元组中还包含其他可变元素,这些可变元素可以改变

    >>> data 
    (99, 88, 77, ['Alex', 'Jack'], 33)
    >>> data[3][0] = '金角大王'
    >>> data
    (99, 88, 77, ['金角大王', 'Jack'], 33)

    字典(dict)

    定义

    {key1:value1,key2:value2}

    1、键与值用冒号“:”分开;
    2、项与项用逗号“,”分开;
    info = {
        "name":"小猿圈",
        "mission": "帮一千万极客高效学编程",
        "website": "http://apeland.com"
    }

    特性

    1. key-value结构

    2. key必须为不可变数据类型、必须唯一

    3. 可存放任意多个value、可修改、可以不唯一

    4. 无序

    5. 查询速度快,且不受dict的大小影响,至于为何快?我们学完hash再解释。创建操作

    创建操作

    >>>person = {"name": "alex", 'age': 20} 
    #
    >>>person = dict(name='seven', age=20)
    #
    >>>person = dict({"name": "egon", 'age': 20})
    #
    >>> {}.fromkeys([1,2,3,4,5,6,7,8],100)
    {1: 100, 2: 100, 3: 100, 4: 100, 5: 100, 6: 100, 7: 100, 8: 100}

    增加操作

    names["佩奇"] = [26, "讲师", 40000]
    
    
    names.setdefault("oldboy",[50,"boss",100000])  
    # 当已经有了value不添加,并返回已有的值

    删除操作

    names.pop("alex") # 删除指定key
    names.popitem()   # 随便删除1个key
    del names["oldboy"] # 删除指定key,同pop方法
    names.clear()     # 清空dict

    修改操作

    dic['key'] = 'new_value'  
    # 如果key在字典中存在,'new_value'将会替代原来的value值;
    >>> aaa = {1:1,2:2}
    >>> aaa[1] = 'asd'
    >>> aaa
    {1: 'asd', 2: 2}
    
    dic.update(dic2)  # 将字典dic2的键值对添加到字典dic中
    >>> aa = {3:3}
    >>> aaa.update(aa)
    >>> aaa
    {1: 'asd', 2: 2, 3: 3}

    查操作

    dic['key']  # 返回字典中key对应的值,若key不存在字典中,则报错;
    >>> aaa[1]
    'asd'
    
    dic.get(key, default = None)  
    # 返回字典中key对应的值,若key不存在字典中,则返回default的值(默认为None)
    
    'key' in dic  # 若存在则返回True,没有则返回False
    
    dic.keys()   # 返回一个包含字典所有KEY的列表;
    
    dic.values()  # 返回一个包含字典所有value的列表;
    
    dic.items()  # 返回一个包含所有(键,值)元组的列表;

    循环

    1、for k in dic.keys()  # 输出key
    2、for k,v in dic.items()  # 输出value
    3、for k in dic   # 推荐用这种,效率速度最快
    info = {
        "name":"小猿圈",
        "mission": "帮一千万极客高效学编程",
        "website": "http://apeland.com"
    }
    for k in info:
        print(k,info[k])
    输出
    name 小猿圈
    mission 帮一千万极客高效学编程
    website http://apeland.com

    求长度

    >>> aaa
    {1: 'asd', 2: 2, 3: 3}
    >>> len(aaa)  # 求长度,有几组key-value
    3

    集合

    定义

    {}内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素

    特性

    1. 里面的元素不可变,代表你不能存一个list、dict 在集合里,字符串、数字、元组等不可变类型可以存

    2. 天生去重,在集合里没办法存重复的元素

    3. 无序,不像列表一样通过索引来标记在列表中的位置 ,元素是无序的,集合中的元素没有先后之分,如集合{3,4,5}和{3,5,4}算作同一个集合

    创建集合

    >>> a = {1,2,3,4,2,'alex',3,'rain','alex'}
    >>> a
    {1, 2, 3, 4, 'alex', 'rain'}

    帮列表去重

    >>> b
    [1, 2, 3, 4, 2, 'alex', 3, 'rain', 'alex']
    >>> set(b)
    {1, 2, 3, 4, 'alex', 'rain'}
    >>> 
    >>> b = list(set(b)) #一句代码搞定
    >>> b
    [1, 2, 3, 4, 'alex', 'rain']

    增删查

    >>> a
    {1, 2, 3, 4, 'alex', 'rain'}
    #新增
    >>> a.add('黑姑娘')  
    
    >>> a
    {2, 3, '黑姑娘', 'alex', 'rain'}
    #删除discard
    >>> a.discard('rain')    # 删除一个存在的值
    >>> a.discard('rain2')   # 如果这个值不存在,do nothing.
    
    >>> a
    {2, 3, '黑姑娘', 'alex'}
    >>> 
    #随机删除,少用,或特定场景用
    >>> a.pop() #删除并返回
    1
    
    #删除remove
    >>> a.remove(4)
    
    #
    >>> a
    {2, 3, '黑姑娘', 'alex', 'rain'}
    >>> 'alex' in a
    True

    关系运算

    s_1024 = {"佩奇","老男孩","海峰","马JJ","老村长","黑姑娘","Alex"}
    s_pornhub = {"Alex","Egon","Rain","马JJ","Nick","Jack"}
    print(s_1024 & s_pornhub)  # 交集, elements in both set
    print(s_1024 | s_pornhub)  # 并集 or 合集
    print(s_1024 - s_pornhub)  # 差集 , only in 1024
    print(s_pornhub - s_1024)  # 差集,  only in pornhub
    print(s_1024 ^ s_pornhub)  # 对称差集, 把脚踩2只船的人T出去
    print(s_1024.isdisjoint(s_pornhub))     
    # 判断2个集合是不是不相交,返回True or False
    
    print(s_1024.issubset(s_pornhub))       
    # 判断s_1024是不是s_pornhub的子集,返回True or False
    
    print(s_1024.issuperset(s_pornhub))     
    # 判断s_1024是不是s_pornhub的父集,返回True or False
  • 相关阅读:
    CSP游戏 4
    CSP 交通规划
    CSP 地铁修建
    CSP 通信网络
    CSP URL映射
    CSP 权限查询
    CSP Markdown
    CSP JSON 查询
    SQL里的子查询
    SQL里的操作符
  • 原文地址:https://www.cnblogs.com/bt14/p/11335737.html
Copyright © 2020-2023  润新知