• Python基础之数据类型


    一、整型

    在Python2中还有整型和长整型之分,但Python3中取消了长整型,统一归类为整型。

    Python中的整型数可以用二进制,八进制,十进制和十六进制几种形式表示

    可以用下面的方法来把十进制转换为其他几种形式

    >>> print(bin(10))           --------->  把十进制转化为二进制
    0b1010
    >>> print(oct(10))           --------->  把十进制转化为八进制
    0o12
    >>> print(hex(10))           --------->  把十进制转化为十六进制
    0xa
    >>> print(hex(100))
    0x64

    二、浮点型

    浮点型数就是小数,因为用科学计数法表示小数时,小数点的位置是可以变化的,所以称为浮点数。在计算机中,整数永远是准确的,而浮点数在四舍五入的过程中却有可能产生误差。小的浮点数可以直接写,但是对于位数很多的浮点数,就必须用科学计数法来表示。把10用e表示,如1.03乘10的9次方,就要写成1.03e9

    三、字符串类型

    定义在引号里面的整体称为字符串,是由一个个字符构成的

    引号可以是单引号,双引号,三引号,多引号...(在Python中,单引号和双引号没有区别)

    字符串的常用操作:

    Python为字符串内置了很多种方法,方便处理需求

    1..strip()    作用是移除空白,可以在()中指定移除的字符,默认为空格

    x='*****abc*****'
    print(x.strip('*'))

    运行结果为:abc

    2..capitalize()   作用是首字母大写

    x='hello world'
    print(x.capitalize())

    运行结果为:Hello world

    3.upper()       作用是所有字母都大写,相反的lower()的作用是所有字母小写

    x='hello world'
    print(x.upper())

    运行结果为:HELLO WORLD

    4..center(self,width,fillchar)       作用是把字符放中间,左右用指定的字符填充至指定的字符长度

    x='hello world'
    print(x.center(30,'*'))

    运行结果为:*********hello world*********

    5..count      作用是统计字符串中某一字符出现的次数,可以指定范围
    x='hello world'
    print(x.count('l',0,10)) 命令的作用是统计“hello world”中第1到11个字符中,‘l’出现的次数
    运行结果为:3

    6..startswith() 以..开头
      x='hello world'
      print(x.startswith('a')) 判断x是否以‘a’开头,如果是,结果为True,如果不是,结果为False
     .endswith()         以..结尾

    7..find() 寻找,如果结果不为负数,则成功。会返回目标字符在字符串中的位置
                 find()和index()的区别是如果找不到对象,find()会返回-1,index()会报错

    8..format        格式化字符串(先举个小例子,后续博客中会详细介绍)
      x='myname:{},age:{},sex:{}'
    print(x.format('zhang',18,'male'))
      
      运行结果为:myname:zhang,age:18,sex:male

    9..index() 查看某个字符的索引,如果超出范围会报错
      x='hello world'
      print(x[1]) ------>e
      print(x[4]) ------>o
      print(x[-1]) ------>d 倒着数
      print(x.index('w')) --------->6 查看某一字符在在字符串中的索引

      字符串的切片操作:print(x[1:3]) -------->el 取x中第1,2个字符
        切片也可以加步长:print(x[1:5:2]) ------->el 取x中第1,2,3,4个字符,但是每两个字符取一次,也就是取第1,3个字符   

    10..isdigit() 查看字符串是否为整数,是则输出True,否则输出False
      x='hello world'
      print(x.isdigit())
      
      False

    11..replace 替换

    x='hello world'
    print(x.replace('e','E')) #不止可以替换字符,也可以替换字符串

    运行结果为:hEllo world

    12..split() 默认以空格为分隔符分割成几部分,当然也可以指定字符作为分隔符
      
      x='hello:world:today:is:a:goodday'
    print(x.split(':'))

      运行结果为:['hello', 'world', 'today', 'is', 'a', 'goodday']

    13..issupper() 判断是否全部为大写
      .islower() 判断是否全部为小写
      .isspace() 判断是否为空格
      .istitle() 判断是否首字母大写

    14..ljust() 左对齐
      .rjust() 右对齐

    15..swapcase() 大小写反转
      .title() 首字母大写

    四、列表 list

     列表中可以存放各种数据类型,以逗号分割开,每个位置存放一个元素

    1.列表的特性:可以存放多个值,每个值对应一个索引值

           列表中的值可变

           按从左到右的顺序定义列表元素,下标从0开始,是有序的

    2.列表的创建

    l=['abc','123',12]           ------>['abc', '123', 12]

    l=list('abc123')         ------>['a', 'b', 'c', '1', '2', '3']

    l=list(['abc','123',12])               ------->['abc', '123', 12]

    3.列表的常用操作

    1)索引

    l=['abc','123',12,[3,'e',5]]

    print(l[0])          -------->abc

    print(l[2])    ---------->12

    print(l[3][2])     ----------->5

    2) 切片

    l=['abc','123',12,'[3,'e',5]]

    print(l[1:3])           --------->['123', 12]

    注意:切片是读操作,原列表并不会发生改变

    3)追加 .append()

    l=['abc','123',12,'[3,'e',5]]

    l.append('hello')

    print(l)         ------------>['abc', '123', 12, [3, 'e', 5], 'hello']

    默认是把字符加在原列表最后边

    4)插入  .insert()

    l=['abc','123',12,'[3,'e',5]]

    l.insert(0,'hello')

    print(l)       ------------>['hello', 'abc', '123', 12, [3, 'e', 5]] 

    注意:insert()中要指定索引位置,必须指定,否则会报错

    5)删除 .pop()

    l=['abc','123',12]

    l.pop(1)

    print(l)     ------------>['abc', 12]

    注意:()中可以指定要删除的元素的索引值,默认是最后一个

       l.pop()是有返回值的,返回删掉的元素

    补充:队列和堆栈

    队列是先进先出,可以用append()和pop(0) 或 insert()和pop()模拟

    堆栈是先进后出,可以用append()和pop() 或insert()和pop(0)模拟

    6)长度 len()

    l=[1,2,3]

    print(len(l))    ---------------------->3

    7)循环

    l=[1,2,3]

    for i in l:

    print(i)           --------------------->1  2  3

    8)包含 in

    l=['a','b','c']     

    print('b' in l)  ------------------------->True

    4.列表的其他操作

    1)查看某一元素的索引 .index()

    l=['a','b','c']

    print(l.index('a'))    ------------------>0

    2)列表中某个元素的数量 .count()

    l=['a','b','c','a']

    print(l.count('a))    -------------->2

    3)追加 .extend() 和append有区别

    l=[1,2,3]
    l.append(['a','b','c'])
    print(l)    -------------->[1, 2, 3, ['a', 'b', 'c']]
    l=[1,2,3]
    l.extend(['a','b','c'])
    print(l)    --------------->[1, 2, 3, 'a', 'b', 'c']

    4)按元素删除 .remove 

     注意当目标元素不存在时会报错,且有多个目标元素时只会删一个

    l=[1,2,3]
    l.remove('a')
    print(l)      ------------->ValueError: list.remove(x): x not in list

    5)排序 .sort()   无返回值

    l=[3,2,4]
    l.sort()
    print(l)    ----------------->[2, 3, 4]

    l=['a','c','d','cd']
    l.sort()
    print(l)    ----------------->['a', 'c', 'cd', 'd']

    l.sort(reverse=True) 表示倒序排列

    6)反转顺序 .reverse()

    五、元组 tuple

    1)元组的定义

    t=('a','b',1,(3,4))

    形式与列表相似,只是[]改成了()

    2)元组的特性:

    元组元素可以是任意数据类型;

    元组是不可变数据类型;

    元组的元素可以是列表,列表的元素可以变,虽然列表的元素改变了,但是列表作为元组的一个元素并没有发生变化,所以不影响元组是不可变数据类型这一特点

    因为元组是不可变数据类型,所以不存在增删改的功能,元组的方法只有count() 和 index()

    3)元组的常用操作有:索引、切片、循环、长度和包含

    4)元组和列表的相互转化:  

    t=('a','b',1,2)
    l=['f','d',4]

    tl=list(tuple(t))
    print(tl,type(tl))    ---------->['a', 'b', 1, 2] <class 'list'>

    lt=tuple(list(l))
    print(lt,type(lt))    ---------->('f', 'd', 4) <class 'tuple'>

    六、字典 dict

    1)字典的定义:

    d={'x':1,'y':1234}

    2)字典的元素是键值对(key - values)

     字典是一种可变数据类型,其中values可变,但是Key不可变

     需注意:定义字典时,key必须是不可变类型,或者说是可hash类型

    3)字典的取值

     字典是无序的,没有索引的概念,通过key来取值 print(d['x']) 就能取到1这个值

     如果key找不到的话会报错,可以用.get(key)   如果找不到key,会打印None,但是不会报错 

    4)修改值

     d['x']='s'  --------把原字典改成了{‘x’:'s','y':1234}

    5)循环 

    d={'name':'zhang','age':18}
    print(d.keys()) #dict_keys(['name', 'age'])
    print(d.values()) #dict_values(['zhang', 18])
    for i in d:
    print(i) #name age 直接遍历字典,打印的是key
    for k in d:
    print(k,d[k]) #name zhang age 18

     因为字典是无序的,所以遍历字典的方法只有 for i in d:这一种

    字典的常用方法:

    1)清除

    d={'x':1}
    d.clear() #清除
    print(d) #{}

    2)避免找不到元素报错的情况

    d={'x':1}
    print(d.get('s')) #None
    print(d('s')) #报错TypeError: 'dict' object is not callable

    3)把键值对转换成元组形式

    d={'x':1}
    d.items()
    for k,v in d.items():
    print(k,v) #x 1

    4)把values转换成列表形式

    d={'x':1,'y':2322}
    print(list(d.values())) #把values值转换成列表形式----------->[1, 2322]

    5)删除 .pop()

    d={'x':1,'y':2322}
    d.pop('x')
    print(d) #{'y': 2322}
    print(d.pop('x')) #1 打印删除的那个值

    6)删除 .popitem()  随机删除

    d={'x':1,'y':2322}
    d.popitem() #括号里不能跟参数,随机删除
    print(d) #{'x': 1}

    7)添加键值对 .setdefault()  括号里是键值对

    d={'x':1}
    d.setdefault('s',2)
    print(d) #{'x': 1, 's': 2} 添加键值对,key和值之间用逗号隔开

    8)产生字典的方法

    d3=dict(x=5,y=2,z=3)                  #{'x': 5, 'y': 2, 'z': 3}   自动生成字典
    d3=dict({'x':1,'y':2}) #{'x': 1, 'y': 2}
    d3=dict([('x',1),('y',2),('z',3)]) #{'x': 1, 'y': 2, 'z': 3}
    d3={}.fromkeys(['name','age'],None) #{'name': None, 'age': None} None的位置只能有一个值,这种方法只能创建这种类型的
    print(d3)

    9)更新字典 .update()

    d={'name':'alex'}
    d1={'name':'alexsb','age':30}
    d.update(d1) #用d1更新字典d
    print(d) #{'name': 'alexsb', 'age': 30}

    10)长度

    d={'name':'zhangcan','age':18,'salary':'100000'}
    print(len(d)) #3
    print(len(d.values())) #3
    print(len(d.items())) #3
    print(len(d.keys())) #3

    11)成员运算

    d={'name':'zhangcan','age':18,'salary':'100000'}
    print('x'in d) #False
    print('name'in d) #True
    print(18 in d)                   #False
    print(18 in d.values())              #True
    print('age' in d.keys())              #True
    print(18 in d.items())              #False
    print(('age',18) in d.items())            #True

    七、布尔类型

    所有的数据类型都自带布尔值(bool),if 判断时,只有0,None,NULL为False,其他都为True

    八、集合(set)
    1.集合的定义

     1)集合内的元素必须是唯一的,可以用这个特性来实现‘去重’的功能  

      s={'egon',123,123,1,'abf'}
      print(s) # {1, 123, 'egon', 'abf'}

     2)集合内的元素必须是可hash的,即不可变的

     3)集合是无序的(无索引)

    2.集合的关系运算(符号)

    s1={'alex','egon','wupeiqi'}
    s2={'alex','egon','zhangcan'}
    print(s1 & s2) #取交集
    print(s1 | s2) #取并集
    print(s1-s2) #差集{'wupeiqi'}
    print(s1^s2) #对称差集{'zhangcan', 'wupeiqi'}

    3.集合的常用命令

    print(s1.difference(s2))    #差集
    print(s1.intersection(s2)) # 交集
    print(s1.union(s2)) #并集
    print(s1.symmetric_difference(s2)) #{'zhangcan', 'wupeiqi'}对称差集
    print(s1.symmetric_difference_update(s2)) #None对称差集并更新回s1
    print(s1) #{'zhangcan', 'wupeiqi'}

    s1.update(s2)       #并集
    print(s1) #{'zhangcan', 'wupeiqi', 'egon', 'alex'}
    s1.add('yuanhao')       #添加元素
    print(s1)

    s1.discard('alex')          #删除(找不到元素不会报错)
    print(s1)

    s1.remove('alex') #删除,但找不到元素会报错

    s1.pop()         #括号里不能有东西,随机删除
    print(s1)

    成员运算:

    s3={'a','b','c',1,2,3}
    s4={1,2,3}
    print(s4.issubset(s3)) #s4是否是s3的子集
    print(s3.issuperset(s4)) #s3是否是s4的超集
    print(s3.isdisjoint(s4)) #s3和s4是否有交集,有交集---False,没有交集---True
  • 相关阅读:
    怎样理解 display:none 和 visibility:hidden
    怎样设置鼠标悬浮时弹出的文字提示框内容
    怎样获取当前元素节点的语言类型
    怎样控制元素节点的是否可拖动属性
    怎样读写分配给当前元素的快捷键
    怎样获取元素节点的标签名称
    怎样查看或修改元素节点的id属性
    怎样使用js将文本复制到系统粘贴板中
    怎样创建一个子树遍历器
    怎样创建一个子节点遍历器
  • 原文地址:https://www.cnblogs.com/zhang-can/p/6959000.html
Copyright © 2020-2023  润新知