zoukankan      html  css  js  c++  java
  • python_04 基本数据类型、数字、字符串、列表、元组、字典

    基本数据类型

    所有的方法(函数)都带括号,且括号内没带等号的参数需传给它一个值,带等号的参数相当于有默认值

    1.数字 int

    在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647
    在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807
    1.int
      将字符串转换为数字
      
    a="123"
    b=int(a)
    print(type(a),a)
    print(type(b),b)
    
    
    
    》》<class 'str'> 123
    》》<class 'int'> 123

    ################################
    num="a"
    v=int(num,base=16)#base=16代表转换为16进制,16进制中a=10,b=11
    print(v)

    》》10
    #####################
    age=3
    r=age.bit_length()#该方法表示当前数字的二进制,至少用n位表示
    print(r)

    》》2
    type()方法返回括号内变量的数据类型
     

    2.字符串 str

    “hello world”  

    a="123"
    b=int(a)
    print(type(a),a)
    print(type(b),b)
    
    》》<class 'str'> 123
    》》<class 'int'> 123
    
    
    #####################
    num="a"
    v=int(num,base=16)#base=16代表转换为16进制,16进制中a=10,b=11
    print(v)
    
    》》10
    
    
    #####################
    age=3
    r=age.bit_length()#该方法表示当前数字的二进制,至少用n位表示
    print(r)
    
    》》2
    
    
    #####################
    test="alex"
    v=test.capitalize()#该方法表示将首字母大写
    print(v)
    
    》》Alex
    
    
    ####################
    #这两个方法都是将字符串所有变小写,casefold()更牛逼
    test1="ALEX"
    v1=test.casefold()
    v2=test.lower()
    print(v1,v2)
    
    >>alex alex
    
    
    ###################
    #这个方法相当于设置宽度,并将内容居中,20代表总长,‘%’代表填充物
    v3=test.center(20,'%') print(v3) >>%%%%%%%%alex%%%%%%%% ################## #这个方法是计算当前字符串中寻找子序列个数 test4="dasdfgrtert" v4=test4.count('d',2,60)#‘d’为寻找目标,2和60表示从第2位开始,第60位结束 print(v4) >>1

    #############################
    #以什么结尾
    #以什么开头
    test5="alex"
    v5=test5.endswith('s')
    v6=test5.startswith('a')
    print(v5)

    》》False
    》》True

    ################################
    #这个方法表示从开始往后找,找到第一个之后,获取其位置
    test6="alexalex"
    v6=test6.find('ex',5,7)#返回-1则没找到,5,7表示[5,7)的前开后闭的区间中找
    print(v6)

    》》6

    ##############################
    #格式化,将字符串中的占位符替换为指定的值
    test7='i am {name},{age}'
    print(test7)
    v7=test7.format(name='alex',age=13)
    print(v7)

    》》i am {name},{age}
    》》i am alex,13
    test8='i am {0},{1}'
    print(test8)
    v8=test8.format('alex',13)
    print(v8)

    》》i am {0},{1}
    》》i am alex,13

    #格式化,传入的值{"name":'alsss',"age":19},相当于字典,"name"和"age"为键
    v9=test7.format_map({"name":'alsss',"age":19})
    print(v9)

    》》i am alsss,19

    ########################
    #判断字符串中是否只包含字母和数字
    test10="asfer454r"
    v10=test10.isalnum()
    print(v10)

    》》True
    #expandtabs()相当于断句,
    test="12345678	9"
    v=test.expandtabs(6)#6表示6个字符串为一句,	表示空格,若出现	则用空格补齐6个字符串
    print(v,len(v))#len()表示字符串长度
    
    
    》》12345678    9 13
    
    test1="name	age	gender
    Manuel	25	male
    April	25	female
    "
    v1=test1.expandtabs(10)
    print(v1)
    
    》》
    name      age       gender
    Manuel    25        male
    April     25        female

    ####################################
    #isalpha()判断当前字符串是否是字母
    #isdecimal()和isdigit()(更牛)和isnumeric()(最牛)判断当前字符串是否是数字
    test2="rggds"
    v2=test2.isalpha()
    v3=test2.isdecimal()
    v4=test2.isdigit()
    v5=test2.isnumeric()
    print(v2,v3,v4)

    》》True False False False


    ###############################

    #是否存在不可显示的字符
    #	   制表符
    # 换行
    test6="wertwet we"
    v6=test6.isprintable()
    print(v6)

    》》False

    isspace()#判断字符串内是否全是空格

    istitle()#判断字符串是否是标题(所有单词首字母大写)

    title()将输入转换为标题的格式

    #jion()将字符串中的每一个元素按照指定分隔符进行拼接
    test7="你是风儿我是沙"
    t='_'
    v7=t.join(test7)
    print(v7)
    
    》》你_是_风_儿_我_是_沙

    ljust()、rjust()与center()类似,区别是将字符串放左边(右边),填充字符串放右边(左边)

    islower()、isupper()判断字符串是否为小写、大写

    lower()、upper()将字符串变成小写、大写

    strip()、lstrip()、rstrip()去掉字符串所有、左边、右边的空格或换行符,括号内为去掉的参数(且参数子序列也可),默认为空格

    #maketrans()建立对应关系,translate()利用对应关系替换
    v8="sssdawrwq"
    m=str.maketrans("sda","123")
    v9=v8.translate(m)
    print(v9)
    
    》》11123wrwq
    #以下方法都是分割
    test10="twqedafsdwsewq"
    m1=test10.partition('e')#只能将字符串分割成3份,遇到的第一个‘e’就分割,且保留‘e’
    m2=test10.rpartition('e')#同上,但是是从右往左
    m3=test10.split('e')#不保留‘e’,默认全部分割,再传个参数可以指定分割次数
    m4=test10.rsplit('e',1)#同上,从右往左
    print(m1)
    print(m2)
    print(m3)
    print(m4)
    
    》》('twq', 'e', 'dafsdwsewq')
    》》('twqedafsdws', 'e', 'wq')
    》》['twq', 'dafsdws', 'wq']
    》》['twqedafsdws', 'wq']
    #正则表达式中可以设置是否想要分割的元素,相当于上面两种方法的合集
    
    #这个方法是根据换行符分割,True,False:指定是否保留换行符
    test11='qwerer
    qweqw
    wafaef'
    m5=test11.splitlines(True)
    print(m5)
    
    》》['qwerer
    ', 'qweqw
    ', 'wafaef']

    startswith()、endswith()判断字符串是否以括号内参数开头或结尾

    swapcace()大小写转换

    replace()将字符串中指定字符或字符串用指定字符或字符串代替

    test1="alexalexalexalexalex"
    v1=test1.replace("ex","bbb",2)#2代表替换次数
    print(v1)
    
    》》albbbalbbbalexalexalex

    6个基本方法:

    jion()、spilt()、find()、strip()、upper()、lower()、replace()

    黑科技:

    1.索引,下标,获取字符串中的某一个字符

    test='alex'
    v0=test[0]
    v1=test[1]
    v2=test[2]
    v3=test[3]
    print(v0,v1,v2,v3)
    
    》》a
    》》l
    》》e
    》》x

    #切片
    v4=test[0:2]#表示从0到2,【0,2)前闭后开区间
    print(v4)

    》》al

    ############################
    v5=len(test5)#获取当前字符串由几个字符组成
    print(v5)

    》》4

    2.注:len()可用于其他数据类型,

    li=[11,22,33,33]
    
    print(len(li))#返回列表长度,用逗号分割
    
    》》4

    3.for i in      循环结构

    test="python真的好简单"
    i=0
    while i<len(test):
        v=test[i]
        print(v)
        i+=1
    print("#############")
    》》p
    y
    t
    h
    o
    n
    真
    的
    好
    简
    单
    #############
    
    for i in test:
        print(i)
    
    
    》》p
    y
    t
    h
    o
    n
    真
    的
    好
    简
    单

    字符串一旦创建不可修改,一旦修改和拼接会在内存中重新创建新的字符串

    3.布尔值 bool

    4.列表 list

    # list #类,列表
    li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]  # 通过list类创建的对象,li
    # 1.列表的格式:中括号括起来
    # 用“,”分割每个元素
    # 2.列表中可嵌套任何类型:列表中的元素可以是数字,字符串,列表,布尔值...所有的都能放进去
    # "集合",内部放任何东西
    
    # 3.索引取值
    print(li[3])
    # 4.切片取值,结果也是列表
    print(li[0:-1])
    
    # 5.for循环
    for item in li:
        print(item)

    列表在内存中是按链表的方式存储的,列表中元素存储不连续,但每个元素所占内存都存储了下一个元素的坐标。所以列表元素与字符串元素不同,可以被修改

    #链表,
    li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
    # 6.列表元素修改
    # 索引方式修改 li[1]=15649 print(li) >>>[1, 15649, 9, 'age', ['是正文', [19, 10]], 'wetrwe', True]

    # 切片方式修改
    li[1:3]=[120,90]
    print(li)

    ################
    #删除列表元素
    del li[1]
    print(li)
    # 7.切片方式删除
    del li[2:5]
    print(li)

    ################
    # 8.in 操作
    li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True] 
    v=120 in li
    print(v)

    v1="是正文" in li[4]
    print(v1)
    >>>False
    >>>True

    9.利用索引取值

    li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
    #取出"19"
    v=li[4][1][0]
    print(v)

    10.字符串转换为列表

    #将字符串转换成列表,本质上去字符串中每一个元素进行for循环添加到列表中
    s="wqrksldkfl"
    new_s=list(s)
    print(new_s)
    
    
    >>>['w', 'q', 'r', 'k', 's', 'l', 'd', 'k', 'f', 'l']
    
    #数字无法参与循环迭代,所以数字无法转换成列

    11.将列表元素转换成字符串

    #将列表元素转换成字符串
    li=[11,22,33,"ww","rerd"]
    
    v1=str(li)#将整个列表转换成字符串,相当于'[11,22,33,"ww","rerd"]'
    print(v1)
    
    >>>[11, 22, 33, 'ww', 'rerd']
    
    v2=""
    for i in li:
        v2+=str(i)
    print(v2)
    
    >>>112233wwrerd
    
    #若列表中元素只有字符串,则可以用jion()方法
    li_01=["fffwe","wqrewqr"]
    v3="".join(li_01)
    print(v3)
    
    >>>fffwewqrewqr

    基本方法:

    1.append()

    #1.追加append(),在原来值后面追加
    li=[11,22,1315,4]
    v=li.append(5)#相当于什么都不是
    print(v)
    print(li)
    
    >>>None
    >>>[11, 22, 1315, 4, 5]
    
    li.append("saf")
    li.append(['wqeqw',12346])
    print(li)
    
    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]

    2.clear()清空列表

    3.复制,拷贝copy()

    4.count(value)计算元素出现的次数

     #2.清空列表clear()li.clear()print(li)
    
    >>>[]
    #3.拷贝,浅拷贝,copy() s=li.copy() print(s)
    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]
    #4.计算元素在列表中的个数count(Value) c=li.count(11) print(c)

    >>>1

    5.extend(iterable)扩展原来的列表,扩展元素必须是可迭代对象(字符串,列表等)

    #5.extend(iterable)扩展原来的列表,扩展元素必须是可迭代对象(字符串,列表等)
    li.extend(["wqewqe",657])
    print(li)
    
    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], 'wqewqe', 657]
    
    与append()的区别:
    li.append(["wqewqe",657])
    print(li)
    
    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], ['wqewqe', 657]]

    ###################
    li.extend("不得了")
    print(li)

    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不', '得', '了']

    li.append("不得了")
    print(li)
    >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不得了']

    6.index(Value,Start=None,End=None)

    #6.index(Value,Start=None,End=None),根据值找索引
    ind=li.index(22)
    print(ind)
    
    >>>1

    7.insert(index,p_object)在指定索引位置插入指定元素

    #7.insert(index,p_object)在指定索引位置插入指定元素
    li.insert(0,'rrr4')
    print(li)

    >>>['rrr4', 11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]

    8.pop(index)删除列表某个值(1.指定索引,2.默认是最后一个)并获取这个值

    remove(Value)删除列表中的指定值,从左往右

    ps:pop()  、 remove() 、 del list[0]  、del list[0:4]   、clear()

    9.reverse()将当前列表反转

    10.sort(key=None,reverse=False),列表的排序,cmp,key  欠

    li=[11,66,55,55,2,44]
    li.sort()
    print(li)
    
    >>>[2, 11, 44, 55, 55, 66]
    
    
    li.sort(reverse=True)
    print(li)
    
    >>>[66, 55, 55, 44, 11, 2]

    对象.方法,# li对象调用append方法 

    补充:列表创建后可以通过索引取值和修改值,字符串创建后可以通过索引取值但不可修改值

    li=[11,22,33,44]
    
    li[0]=999
    
    print(li)
    
    >>>[999,22,33,44]
    
    s="alexs"
    
    print(s[0])
    
    >>>a

    列表是有序的,元素可以被修改

    5.元组 tuple

    #相当于对列表的二次加工,元组元素不可被修改,不能增加或删除

    #tuple   类

    tu=(111,222,"alex",(11,22,33),[0,1,2,3],True,5s5)

    书写格式#一般写元组的时候,推荐在最后加入“,”,便于与方法区分

    s="asf32 5we"
    li=["y5rty","52"]
    tu=("sgsdrrrt",['fff',456],526,)
    
    v0=list(s)
    print(v0)
    
    v1=tuple(s)
    print(v1)
    
    v2=tuple(li)
    print(v2)
    
    v3=list(tu)
    print(v3)
    
    v4=str(li)
    print(v4)
    
    v5=str(tu)
    print(v5)
    
    #列表转换为字符串,当列表中只含有字符串时
    l=["wrerewr","ewrewr","esadsad"]
    v6="".join(l)
    print(v6)
    
    #元组转换为字符串,当元组中只含有字符串时
    t=("ewrsgf","tryrty","241",)
    v7="_".join(t)
    print(v7)

    >>>['a', 's', 'f', '3', '2', ' ', '5', 'w', 'e']

     >>>('a', 's', 'f', '3', '2', ' ', '5', 'w', 'e')
      >>>('y5rty', '52')
      >>>['sgsdrrrt', ['fff', 456], 526]
      >>>['y5rty', '52']
      >>>('sgsdrrrt', ['fff', 456], 526)
      >>>wrerewrewrewresadsad
      >>>ewrsgf_tryrty_241

    #元组转换为字符串,当元组中不仅仅含有字符串时
    s1=""
    for i in tu:
        s1=s1+str(i)
    print(s1)
    
    >>>sgsdrrrt['fff', 456]526

    元组也是有序的,元组的一级元素不可修改/删除/增加,但里面嵌套的列表可修改

    #元组是有序的
    tu=(123,5456,"asldw",[(545,555,)],True,3,4)
    #找出555元素
    print(tu[3][0][1])
    
    >>>555
    
    #####################
    #元组的一级元素不可修改/删除/增加,但里面嵌套的列表可修改
    tu[3].append(567)
    print(tu)
    
    
    >>>(123, 5456, 'asldw', [(545, 555), 567], True, 3, 4)

    基本方法:

    1.count()获取指定元素在元组中出现的次数

    2.index()获取某个值的索引位置

    6.字典 dict

    #dict    类

    1.字典的value可以是任何值

    info={

      "k1":"v1",#键值对 

      "k2":"v2"}

    #字典的value可以是任何值
    info1={
        "k1":23,
        "k2":True,
        "k3":[11,22,22,{
            'kk1':'vv1',
            'kk2':'vv2',
            'kk3':(44,55,)
        }],
        "k4":(34,54,6,)
    }
    print(info)

    >>>{'k1': 23, 'k2': True, 'k3': [11, 22, 22, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (44, 55)}], 'k4': (34, 54, 6)}

     2.列表和字典不能作为字典的key

    #列表和字典不能作为字典的key
    info2={
        123:'erwer',
        "k1":'rewr',
        (33,44,):'ertd',
        True:'fgf',
    }
    print(info2)
    
    >>>{123: 'erwer', 'k1': 'rewr', (33, 44): 'ertd', True: 'fgf'}

    3.字典是无序的

    4.可以根据索引输入字典键值key获取对应的值,不可通过切片查找,因为无序

    #获取‘ertd’
    v2=info2[(33,44,)]
    print(v2)
    
    #获取'44'
    v1=info1['k3'][3]['kk3'][0]
    print(v1)

    5.字典元素的删除

    del info['k3'][3]['kk1'']

    6.字典的for循环

    #for循环
    for item in info1:#默认获取key值
        print(item)
    
    for item in info1.keys():
        print(item)
    
    for item in info1.values():#获取value
        print(item)
    
    for k,v in info1.items():#获取Key和value
        print(k,v)

    基本方法

    1.clear()删除

    2.copy()复制,浅复制

    @staticmethod 静态方法,支持直接写类名后带“.”可执行该功能如dict.fromkeys

    3.dict.fromkeys()根据序列,创建字典,并指定统一的值

    v=dict.fromkeys(["k1",123,"9990"],12345)
    print(v)
    
    >>>{'k1': 12345, 123: 12345, '9990': 12345}

    4.get()

    info={
        "k1":"v1"
    }
    
    a=info.get("k1",456478)#45678为默认若取不到相应的键值则返回的值
    print(a)
    b=info.get("rewrwer","wqerqwr")#若不传入值,则默认返回None
    print(b)
    >>>v1
    >>>wqerqwr

    5.pop(k,d=None),删除传入k值,返回当前删除的key值,当k不存在字典中时,返回d,默认为None

    6.popitem(),删除字典中的值,返回键值对,默认返回元组类型,若k,v=popitem(),则返回两个值

    a1=info.pop("k122",999)
    print(a1)
    print(info)
    
    a2=info.popitem()
    print(a2)
    print(info)
    
    a3,b3=info.popitem()
    print(a3,b3)
    print(info)
    
    >>>999
    >>>{'k1': 'v1', 'k2': 'v2'}
    >>>('k2', 'v2')
    >>>{'k1': 'v1'}
    >>>k1 v1
    >>>{}

    7.setdefalt(k,d=None)在字典中设置值,若已存在,则获取当前key对应的值,若不存在则设置值并获取当前对应的值,

    info={
        "k1":"v1",
        "k2":"v2"
    }
    
    a1=info.setdefault("k1",123)
    print(info,a1)
    a2=info.setdefault("rree",123)
    print(info,a2)
    
    >>>{'k1': 'v1', 'k2': 'v2'} v1
    
    >>>{'k1': 'v1', 'k2': 'v2', 'rree': 123} 123

    8.update(E=None,**F)***kwargs这种参数python将自动转换成相应的格式

    info={
        "k1":"v1",
        "k2":"v2"
    }
    
    info.update({'k1':454,"k3":48478})
    print(info)
    
    info.update(k1=123,k3=48789,k4="erwr")
    print(info)
    
    >>>{'k1': 454, 'k2': 'v2', 'k3': 48478}
    >>>{'k1': 123, 'k2': 'v2', 'k3': 48789, 'k4': 'erwr'}

    总结

    一、数字

    int()

    二、字符串

    replace/fin/jion/strip/startwith/spilt/upper/lower/format

    例:

    template="I am {name},age:{19}"

    v=template.formate(**{"name":"alex","age":19})

    print(v)

    三、列表

    append/extend/insert

    索引、切片、循环

    四、元组

    索引、切片、循环

    一级元素不能被修改增加删除

    五、字典

    get/update/keys/values/items

    for,索引

    例:in在字典的用法

      dic={ "k1":"v1"}

      v="k1"in dic

      print(v)

    六、布尔值

    0 1 

    bool()

    0,None,“”,(),[ ],{ }都是False,其余都是True

    补充:

    enumrate(object,),为可迭代对象添加序号

    li = [11,22,33]
    for k,v in enumerate(li, 1):
        print(k,v)

    >>>1 11
    >>>2 22
    >>>3 33
  • 相关阅读:
    uva 10369 Arctic Network
    uvalive 5834 Genghis Khan The Conqueror
    uvalive 4848 Tour Belt
    uvalive 4960 Sensor Network
    codeforces 798c Mike And Gcd Problem
    codeforces 796c Bank Hacking
    codeforces 768c Jon Snow And His Favourite Number
    hdu 1114 Piggy-Bank
    poj 1276 Cash Machine
    bzoj 2423 最长公共子序列
  • 原文地址:https://www.cnblogs.com/Manuel/p/10452269.html
Copyright © 2011-2022 走看看