• Python基础二


    一. 什么是数据类型?

        讲数据类型之前首先要了解什么是数据类型,那数据类型是什么呢?

        我们人类可以很容易的分清数字与字符的区别,但是计算机并不能呀,计算机虽然很强大,但从某种角度上看又很傻,除非你明确的告诉它,1是数字,“汉”是文字,否则它是分不清1和‘汉’的区别的,因此,在每个编程语言里都会有一个叫数据类型的东东,其实就是对常用的各种数据类型进行了明确的划分,你想让计算机进行数值运算,你就传数字给它,你想让他处理文字,就传字符串类型给他。Python中常用的数据类型有多种,如下:整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

        (1)int  数字:主要用于运算。1 ,2,3...

        (2)bool  判断真假:True, False.

        (3)str  简单少量的储存数据,并进行相应的操作。name = 'alex'.

        (4)tuple  只读,不能更改。(1,'alex') .

        (5)list:大量有序数据,[1,'ses',True,[1,2,3],{'name':'jinxin'}].

        (6)dict:大量数据,且是关联性比较强的数据  {'name':'jinxin','age':18,'name_list':['张三','李四']}.

    二. 基础数据类型

        2.1 数字int

         int,就是最常见的数据类型,主要用于各种运算,加减乘除等

         首先要给大家讲下是十进制与二进制之间的转换。

         2.1.1 十进制二进制转换

         十进制整数转换为二进制整数采用"除2取余,逆序排列"法。具体做法是:用2整除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。

         

        十进制小数转换成二进制小数采用"乘2取整,顺序排列"法。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,此时0或1为二进制的最后一位。或者达到所要求的精度为止。

        

        二进制转化成十进制:

        要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右

        例1:二进制数1101.01转化成十进制

        1101.01(2)=1*2^0+0*2^1+1*2^2+1*2^3 +0*2-1+1*2-2=1+0+4+8+0+0.25=13.25(10)

        所以总结起来通用公式为:

        abcd.efg(2)=d*2^0+c*2^1+b*2^2+a*2^3+e*2-1+f*2-2+g*2-3(10)

        或者是:

        把二进制数首先写成加权系数展开式,然后按十进制加法规则求和。这种做法称为"按权相加"法。

        

        此时,1101=8+4+0+1=13

        再比如:二进制数100011转成十进制数可以看作这样:

        数字中共有三个1 即第一位一个,第五位一个,第六位一个,然后对应十进制数即2的0次方+2的1次方+2的5次方, 即

        100011=32+0+0+0+2+1=35

        2.2.2 int操作方法

        因为数字主要是用于计算,所以针对于数字可以使用的方法除了那些运算之外,没有什么经常会用的方法,python给咱们提供了一种方法:bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.

        

        2.2 布尔值bool

        布尔值就两种:True,False。就是反应条件的正确与否。

        真   1   True。

        假   0   False。  

        这里补充一下int str bool 三者数据类型之间的转换。

        # int ---> bool
        i = 100
        print(bool(i)) # True # 非零即True
        i1 = 0
        print(bool(i1)) # False 零即False

        # bool ---> int
        t = True
        print(int(t)) # 1 True --> 1
        t = False
        print(int(t)) # 0 False --> 0

        # int ---> str
        i1 = 100
        print(str(i1)) # '100'

        # str ---> int # 全部由数字组成的字符串才可以转化成数字
        s1 = '90'
        print(int(s1)) # 90

        # str ---> bool
        s1 = '太白'
        s2 = ''
        print(bool(s1)) # True 非空即True
        print(bool(s2)) # False
        # bool ---> str
        t1 = True
        print(str(True)) # 'True'

        2.2 字符串str

        Python中凡是用引号引起来的数据可以称为字符串类型,组成字符串的每个元素称之为字符,将这些字符一个一个连接起来,然后在用引号起来就是字符串。

    s1 = '测试nb'
    # 对于s1这个字符串来说,它由四个字符组成:测, 试, n, b。

        2.3.1 字符串的索引与切片

        组成字符串的字符从左至右,依次排列,他们都是有顺序的,就好比是部队的队列,从左至右依次报号(从零开始) :0,1,2,3....

        

        索引即下标,就是字符串组成的元素从第一个开始,初始索引为0以此类推。

        

        切片就是通过索引(索引:索引:步长)截取字符串的一段,形成新的字符串(原则就是顾头不顾腚)。

        

        2.3.2 字符串常用方法

        字符串除了可以用切片(步长)之外,还有一些其他的操作方法。

        #数字符串中的元素出现的个数。

        例1:

        # ret3 = a1.count("a",0,4) # 可切片
        # print(ret3)

        a4 = "dkfjdkfasf54"
        #startswith 判断是否以...开头
        #endswith 判断是否以...结尾
        # ret4 = a4.endswith('jdk',3,6) # 顾头不顾腚
        # print(ret4) # 返回的是布尔值
        # ret5 = a4.startswith("kfj",1,4)
        # print(ret5)

        #split 以什么分割,最终形成一个列表此列表不含有这个分割的元素。
        # ret9 = 'title,Tilte,atre,'.split('t')
        # print(ret9)
        # ret91 = 'title,Tilte,atre,'.rsplit('t',1)
        # print(ret91)

        #format的三种玩法 格式化输出
        res='{} {} {}'.format('egon',18,'male')
        res='{1} {0} {1}'.format('egon',18,'male')
        res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

        #strip
        name='*barry**'
        print(name.strip('*'))
        print(name.lstrip('*'))
        print(name.rstrip('*'))

        #replace
        name='alex say :i have one tesla,my name is alex'
        print(name.replace('alex','SB',1))

        #####is系列
        name='taibai123'
        print(name.isalnum()) #字符串由字母或数字组成
        print(name.isalpha()) #字符串只由字母组成
        print(name.isdecimal()) #字符串只由十进制组成

        2.4列表list

        Why: 我们现在已经学过的数据类型有:数字,布尔值,字符串,大家都知道数字主要用于计算,bool值主要是条件判断,只有字符串可以用于数据的存储,这些数据类型够用么?对于一门语言来说,肯定是不够用的。就说字符串:

        1,字符串只能存储少量的数据,对于大量的数据用字符串操作不方便也不易存储。

        2,字符串存储的数据类型太单一,只能是字符串类型。

        例如:‘1 True alex’ 像这样的字符串,我如果通过切片或者其他方法将1 True alex 取出来,他也只能是字符串,但是我想要得到数字的1,布尔值的True,必须还要转化,是不是很麻烦。

        所以python给咱们也提供了一类数据类型,他能承载多种数据类型,这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。

        What:这个数据类型就是list列表。

        列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型比如:

        例1:li = [‘Tom’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

    列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据,32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的,有索引值,可切片,方便取值。

        How:那么这个列表如何使用呢?咱们从这几方面去深入研究这个列表。

        2.4.1 列表的创建

        # 创建一个列表有三种方式:

        # 方式一:(常用)
        l1 = [1, 2, '测试']

        # 方式二:(不常用)
        l1 = list() # 空列表
        # l1 = list(iterable) # 可迭代对象
        l1 = list('123')
        print(l1) # ['1', '2', '3']

        # 方式三:列表推导式(后面的课程会讲到)
        l1 = [i for i in range(1,5)]
        print(l1) # [1, 2, 3, 4]

        2.4.2 列表的索引切片

     l1 = ['a', 'b', '测试', 3, 666]
     print(l1[0])  # 'a'
     print(l1[-1])  # 666
     print(l1[1:3])  # ['b', '测试']
     print(l1[:-1])  # ['a', 'b', '测试', 3]
     print(l1[::2])  # ['a', '测试', 666]
     print(l1[::-1])  # [666, 3, '测试', 'b', 'a']

    2.4.3 增
     # append 追加,给列表的最后面追加一个元素
     l = [1, 2, 'a']
     l.append(666)
     print(l) # [1, 2, 'a', 666]
    
     # insert  插入在列表的任意位置插入元素
     l = [1, 2, 'a']
     l.insert(1,'测试')
     print(l) # [1, '测试', 2, 'a']
    
     # extend  迭代着追加,在列表的最后面迭代着追加一组数据
     l = [1, 2, 'a']
     l.extend('测试a')
     print(l)
    2.4.4 删

        # pop 通过索引删除列表中对应的元素,该方法有返回值,返回值为删除的元素
        l = ['测试', 'alex', 'WuSir', '女神']
        ret = l.pop(1)
        print(ret,l) # alex ['测试', 'WuSir', '女神']

        # remove 通过元素删除列表中该元素
        l = ['测试', 'alex', 'WuSir', '女神']
        l.remove('alex')
        print(l) # ['测试', 'WuSir', '女神']

        # clear 清空列表
        l = ['测试', 'alex', 'WuSir', '女神']
        l.clear()
        print(l) # []

        # del
        #按照索引删除该元素
        l = ['测试', 'alex', 'WuSir', '女神']
        del l[2]
        print(l) # ['测试', 'alex', '女神']

        # 切片删除该元素
        l = ['测试', 'alex', 'WuSir', '女神']
        del l[1:]
        print(l) # ['测试']

        # 切片(步长)删除该元素
        l = ['测试', 'alex', 'WuSir', '女神']
        del l[::2]
        print(l) # ['alex', '女神']

        列表的删

    2.4.5. 改

        # 按照索引改值
        l = ['测试', 'alex', 'WuSir', '女神']
        l[0] = '男神'
        print(l) # ['男神', 'alex', 'WuSir', '女神']

    
    

        # 按照切片改值(迭代着增加)
        l = ['测试', 'alex', 'WuSir', '女神']
        l[1:3] = 'abcdefg'
        print(l) # ['测试', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神']

    
    

        # 按照切片(步长)改值(必须一一对应)
        l = ['测试', 'alex', 'WuSir', '女神']
        l[::2] = '对应'
        print(l) # ['对', 'alex', '应', '女神']

    列表的改

        2.4.6. 查

    切片去查,或者循环去查。

        2.4.7. 其他操作

        count(数)(方法统计某个元素在列表中出现的次数)。

    1 a = ["q","w","q","r","t","y"]
    2 print(a.count("q"))

        index(方法用于从列表中找出某个值第一个匹配项的索引位置)

    1 a = ["q","w","r","t","y"]
    2 print(a.index("r"))

        sort (方法用于在原位置对列表进行排序)。

        reverse (方法将列表中的元素反向存放)。

    1 a = [2,1,3,4,5]
    2 a.sort()# 他没有返回值,所以只能打印a
    3 print(a)
    4 a.reverse()#他也没有返回值,所以只能打印a
    5 print(a)
    列表也可以相加与整数相乘
     l1 = [1, 2, 3]
     l2 = [4, 5, 6]
     # print(l1+l2)  # [1, 2, 3, 4, 5, 6]
     print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

    2.4.8 列表的嵌套
     l1 = [1, 2, 'taibai', [1, 'WuSir', 3,]]
     1, 将l1中的'taibai'变成大写并放回原处。
     2,给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
     3,将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'

        Where:(这个知识点用在什么地方):

      你需要存储大量的数据,且需要这些数据有序的时候。

      制定一些特殊的数据群体:按顺序,按规则,自定制设计数据。

        2.5 元组tuple

        Why:对于容器型数据类型list,无论谁都可以对其增删改查,那么有一些重要的数据放在list中是不安全的,所以需要一种容器类的数据类型存放重要的数据,创建之初只能查看而不能增删改,这种数据类型就是元组。

        what:这个容器型数据类型就是元组。

        元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

        2.5.1 元组的索引切片

        例1:

        tu1 = ('a', 'b', '测试', 3, 666)
        print(tu1[0]) # 'a'
        print(tu1[-1]) # 666
        print(tu1[1:3]) # ('b', '测试')
        print(tu1[:-1]) # ('a', 'b', '测试', 3)
        print(tu1[::2]) # ('a', '测试', 666)
        print(tu1[::-1]) # (666, 3, '测试', 'b', 'a')

        2.5.2 元组其他操作方法

        因为元组的特性,直接从属于元组的元素不能更改,所以元组只能查看。

        例1:

     # 可以利用for循环查询
     tu1 = ('a', 'b', '测试', 3, 666)
     for i in tu1:
         print(i)

    index:通过元素找索引(可切片),找到第一个元素就返回,找不到该元素即报错。
     例2:

    tu = ('测试', [1, 2, 3, ], 'WuSir', '女神') print(tu.index('测试')) # 0

    count: 获取某元素在列表中出现的次数

    例3:
     tu = ('测试', '测试', 'WuSir', '吴超')
     print(tu.count('测试')) # 2

    2.5.3 len


        Where:

        1,就是将一些非常重要的不可让人改动的数据放在元组中,只供查看。

        2,常用于元组的拆包(数据类型补充的时候会给大家讲到)。

        2.6 字典dict

        2.6.1 字典的初识

        Why:咱们目前已经学习到的容器型数据类型只有list,那么list够用?他有什么缺点呢?

            1. 列表可以存储大量的数据类型,但是如果数据量大的话,他的查询速度比较慢。

            2. 列表只能按照顺序存储,数据与数据之间关联性不强。

            所以针对于上的缺点,说咱们需要引入另一种容器型的数据类型,解决上面的问题,这就需要dict字典。

        what:

            数据类型可以按照多种角度进行分类,就跟咱们人一样,人按照地域可以划分分为亚洲人,欧洲人,美洲人等,但是按照肤色又可以分为白种人,黄种人,黑种人,等等,数据类型可以按照不同的角度进行分类,先给大家按照可变与不可变的数据类型的分类:

            不可变(可哈希)的数据类型:int,str,bool,tuple。

            可变(不可哈希)的数据类型:list,dict,set。

            字典是Python语言中的映射类型,他是以{}括起来,里面的内容是以键值对的形式储存的:

            Key: 不可变(可哈希)的数据类型.并且键是唯一的,不重复的。

            Value:任意数据(int,str,bool,tuple,list,dict,set),包括后面要学的实例对象等。

         在Python3.5版本(包括此版本)之前,字典是无序的。

         在Python3.6版本之后,字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

         当然,字典也有缺点:他的缺点就是内存消耗巨大。

        2.6.2 创建字典的几种方式:

        # 创建字典的几种方式:

        # 方式1:
        dic = dict((('one', 1),('two', 2),('three', 3)))
        # dic = dict([('one', 1),('two', 2),('three', 3)])
        print(dic) # {'one': 1, 'two': 2, 'three': 3}

        # 方式2:
        dic = dict(one=1,two=2,three=3)
        print(dic) # {'one': 1, 'two': 2, 'three': 3}

        # 方式3:
        dic = dict({'one': 1, 'two': 2, 'three': 3})
        print(dic) # {'one': 1, 'two': 2, 'three': 3}

        # 方式5: 后面会讲到先了解
        dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
        print(dic)

        # 方式6: 字典推导式 后面会讲到
        # dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
        # print(dic)

        # 方式7:利用fromkey后面会讲到。
        # dic = dict.fromkeys('abcd','测试')
        # print(dic) # {'a': '测试', 'b': '测试', 'c': '测试', 'd': '测试'}

        2.6.3 验证字典的合法性

        # 合法
        dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
        哥', '美⼥'], (1, 2, 3): '麻花藤'}
        print(dic[123])
        print(dic[True])
        print(dic['id'])
        print(dic['stu'])
        print(dic[(1, 2, 3)])

        # 不合法
        # dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
        # dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
        dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

        2.6.4 字典的常用操作方法

        接下来咱们就进入字典的学习环节,字典对于咱们小白来说可能相对于列表是不好理解的,因为列表是有序的一个一个排列的,但是字典的键值对对于大家来说是比较陌生的,所以咱们可以把字典比喻成一个公寓,公寓里面有N多个房间,房间号就是键,房间里面具体的东西就值:比如房间001号:对应的房间住着两个人,也就是2person,简称2P,房间99号:3P, 房间78号:有人还有小动物....... 这样,咱们就能通过房间号(也就是键)找到对应的房间,查看里面的内容,也就是值。

        那么首先先从字典的增删改查开始学习。

           

        # 通过键值对直接增加
        dic = {'name': '测试', 'age': 18}
        dic['weight'] = 75 # 没有weight这个键,就增加键值对
        print(dic) # {'name': '测试', 'age': 18, 'weight': 75}
        dic['name'] = 'barry' # 有name这个键,就成了字典的改值
        print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

        # setdefault
        dic = {'name': '测试', 'age': 18}
        dic.setdefault('height',175) # 没有height此键,则添加
        print(dic) # {'name': '测试', 'age': 18, 'height': 175}
        dic.setdefault('name','barry') # 有此键则不变
        print(dic) # {'name': '测试', 'age': 18, 'height': 175}
        #它有返回值
        dic = {'name': '测试', 'age': 18}
        ret = dic.setdefault('name')
        print(ret) # 测试

        字典的增

        

        # pop 通过key删除字典的键值对,有返回值,可设置返回值。
        dic = {'name': '测试', 'age': 18}
        # ret = dic.pop('name')
        # print(ret,dic) # 测试 {'age': 18}
        ret1 = dic.pop('n',None)
        print(ret1,dic) # None {'name': '测试', 'age': 18}

        #popitem 3.5版本之前,popitem为随机删除,3.6之后为删除最后一个,有返回值
        dic = {'name': '测试', 'age': 18}
        ret = dic.popitem()
        print(ret,dic) # ('age', 18) {'name': '测试'}

        #clear 清空字典
        dic = {'name': '测试', 'age': 18}
        dic.clear()
        print(dic) # {}

        # del
        # 通过键删除键值对
        dic = {'name': '测试', 'age': 18}
        del dic['name']
        print(dic) # {'age': 18}
        #删除整个字典
        del dic

       字典的删

        

        # 通过键值对直接改
        dic = {'name': '测试', 'age': 18}
        dic['name'] = 'barry'
        print(dic) # {'name': 'barry', 'age': 18}

        # update
        dic = {'name': '测试', 'age': 18}
        dic.update(sex='男', height=175)
        print(dic) # {'name': '测试', 'age': 18, 'sex': '男', 'height': 175}

        dic = {'name': '测试', 'age': 18}
        dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
        print(dic) # {'name': '测试', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

        dic1 = {"name":"jin","age":18,"sex":"male"}
        dic2 = {"name":"alex","weight":75}
        dic1.update(dic2)
        print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
        print(dic2) # {'name': 'alex', 'weight': 75}

        字典的改

        

        # 通过键查询
        # 直接dic[key](没有此键会报错)
        dic = {'name': '测试', 'age': 18}
        print(dic['name']) # 测试

        # get
        dic = {'name': '测试', 'age': 18}
        v = dic.get('name')
        print(v) # '测试'
        v = dic.get('name1')
        print(v) # None
        v = dic.get('name2','没有此键')
        print(v) # 没有此键


        keys()
        dic = {'name': '测试', 'age': 18}
        print(dic.keys()) # dict_keys(['name', 'age'])

        values()
        dic = {'name': '测试', 'age': 18}
        print(dic.values()) # dict_values(['测试', 18])

        items()
        dic = {'name': '测试', 'age': 18}
        print(dic.items()) # dict_items([('name', '测试'), ('age', 18)])

        字典的查

        今天的课程就到这里了,敬请期待下期课程。

  • 相关阅读:
    python之元组
    python之dict
    python之list
    python之str字符串
    python之for循环
    Python的基本语法2
    Python的基本语法1
    初识python
    JS获取当天是周几
    EXCLE导入数据库
  • 原文地址:https://www.cnblogs.com/zhouxuyang1/p/10816047.html
Copyright © 2020-2023  润新知