• Python数据类型之基础记。。。


    数据类型

    1、什么是数据?为何要有数据?

    ==>    x=10,10是我们要存储的数据 。数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示

    2、数据类型

    A*数字(整型,长整型,浮点型,复数)

    B*字符串

    C*列表

    D*元组

    E*字典

    F*集合

    3、数据的使用一般是按照以下几点展开

    #======================================基本使用======================================
    #1、用途

    #2、定义方式

    #3、常用操作+内置的方法

    #======================================该类型总结====================================
    #存一个值or存多个值
       
    #有序or无序

    #可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
    #AAA* 一:整型int

    # ======================================基本使用======================================

    # 1、用途:年龄、个数、号码、出生年等

    # 2、定义方式

    # age = 18 # age = int(18)

    # int功能可以把纯数字的字符串转换成int类型

    # res = int("18")

    # # res = int("1.8")

    # print(type(res))

    # 了解(***)

    # print(bin(11)) # 0b1011

    # print(oct(11)) # 0o13

    # print(hex(11)) # 0xb

    # 3、常用操作+内置的方法

    # 算数运算符与比较运算

    # 二:浮点型float

    # ======================================基本使用======================================

    # 1、用途:薪资、身高、体重等

    # 2、定义方式

    salary = 3.1 # salary = float(3.1)

    # float功能可以把浮点数组成的字符串转换成float类型

    # res = float("1.8")

    # print(type(res))


    # 3、常用操作+内置的方法

    # 算数运算符与比较运算

    # ======================================该类型总结====================================

    # 存一个值

    # 不可变
    # ======================================基本使用======================================

    #BBB 1、用途:记录描述性质的状态,例如名字、性别、国籍等

    # 2、定义方式:在引号('',"",'''''',""""""")内包含一串字符串

    s = "hello" # s = str("hello")

    # str功能可以把任意类型转换成str类型

    # res=str([1,2,3]) # "[1,2,3]"

    # print(type(res))

    # 3、常用操作+内置的方法

    # =======================>优先掌握的操作:

    # 1、按索引取值(正向取+反向取) :只能取

    s = "hello world"

    # print(s[0],type(s[0])) # "h"

    # print(s[-1])

    # s[1] = "E" # 不能修改

    # 非法操作

    # s[2222]

    # s[11] = "A"

    # 2、切片(顾头不顾尾,步长)=>属于拷贝操作

    s = "hello world"

    # new_s=s[1:7]

    # print(new_s)

    # print(s)

    # new_s=s[1:7:2] #1 3 5

    # print(new_s)

    # print(s)

    # new_s=s[:7:2]

    # new_s=s[::2] # 0 2 4 6 8 10

    #               h l o w r d

    # print(new_s)

    # new_s=s[::] # 完整拷贝字符串,只留一个冒号就可以new_s=s[:]

    # print(new_s)


    # 3、长度len

    # s = "hello world"

    # print(len(s))

    # res=print("sfd")

    # print(res)

    # 4、成员运算in和not in

    # s = "hello world"

    # # print("hel" in s)

    # print("egon" not in s) # 语义明确,推荐使用

    # # print(not "egon" in s)

    # 5、移除空白strip

    # s = "       hel lo "

    # new_s = s.strip()

    # print(new_s)

    # print(s) # 没有改变原字符串

    # 应用案列:

    # name = input("your name>>> ").strip() # name = "egon "

    # pwd = input("your pwd>>> ").strip()

    #

    # if name == "egon" and pwd == "123":

    #     print('login successful')

    # else:

    #     print('user or password error')


    # 去除左右两边的非空白字符

    # print("**+=-%^#****he**llo**%^#**+=**".strip("*+=-%^#"))

    # 6、切分split:把字符串按照某个分隔符切成一个列表

    # userinfo = "egon_dsb:123:18:3.1"

    # res = userinfo.split(":")

    # # print(res[0])

    # print(res)

    # print("-".join(res))

    # 纯字符串组成的列表

    # l = ["aaaa", "bbb", "ccc"]

    #

    # # res=l[0]+":"+l[1]+":"+l[2]

    # res = ":".join(l)

    # print(res, type(res))

    # 7、循环

    # for i in "hello":

    #     print(i)


    # =======================>需要掌握的操作:

    # 1、strip,lstrip,rstrip

    # print("***hello***".strip("*"))

    # print("***hello***".lstrip("*"))

    # print("***hello***".rstrip("*"))

    # 2、lower,upper

    # msg = "AbCDEFGhigklmn"

    # res = msg.lower()

    # res = msg.upper()

    # print(res)

    # res=msg.swapcase()

    # print(res)

    # 3、startswith,endswith

    # msg = "sb is lxx sb"

    # print(msg.startswith("sb"))

    # print(msg.endswith("b"))

    # print(msg.endswith("c"))

    # 5、split,rsplit

    # userinfo="egon:123:18"

    # # print(userinfo.split(":"))

    # print(userinfo.split(":",1))

    # print(userinfo.rsplit(":",1))

    # 6、join

    # 7、replace

    msg = "***egon hello***"

    # res=msg.replace('*','').replace(' ','')

    # res=msg.strip('*').replace(' ','')

    # print(res)

    # s="lxx hahah wocale lxx sb 666"

    # # res=s.replace('lxx','sb')

    # res=s.replace('lxx','sb',1)

    # print(res)

    # print(s)

    # 4、format的三种玩法

    # 4.1 %s的方式

    # name = "egon"

    # age = 18

    # res1="my name is %s my age is %s" % (name,age)

    # print(res1)

    # 4.2 format的方式

    # name = "egon"

    # age = 18

    # res1="my name is {} my age is {}".format(name,age)

    # res1="{0}{0}{0}{1}".format(name,age)

    # res1="my name is {name} my age is {age}".format(age=18,name="egon")

    # print(res1)

    # 4.3 f.txt''

    # name = "egon"

    # age = 18

    # res1 = f.txt"my name is {name} my age is {age}"

    # print(res1)


    # 了解:f搭配{}可以执行字符串中的代码

    # res=f.txt'{len("hello")}'

    # print(res)

    # f.txt'{print("hello")}'

    # f包含的字符串可以放到多行

    # name = "egon"

    # age = 18

    # res1 = f.txt"my name is {name} "

    #       f.txt"my age is {age}"

    # {}内不能有以及#

    # print(f.txt'my name is {{egon}}')

    # print('胜率是 %s%%' %70)

    # 了解:https://zhuanlan.zhihu.com/p/110406030

    # 8、isdigit:判断字符串是否由纯数字组成

    # print("adsf123".isdigit())

    # print("123".isdigit())

    # print("12.3".isdigit())

    age = input('>>>: ') # age = "       18     "
    if age.isdigit():
      age=int(age)
      if age > 18:
          print('猜大了')
      elif age < 18:
          print('猜小了')
      else:
          print('猜对了')
    else:
      print('必须输入数字,小垃圾')

    # =======================>了解的操作:


    # ======================================该类型总结====================================

    # 存一个值or存多个值

    # 有序or无序

    # 可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)

    #1、find,rfind,index,rindex,count(字符串内置方法)

    # x = "hello egon egon egon"

    # res=x.find("egon")

    # res=x.find("egon123") # -1代表没有找到

    # print(res)

    # res=x.rfind("egon")

    # print(res)

    # res=x.find("egon",0,3)

    # print(res)


    # res = x.index("egon123") # 找不到则报错

    # print(res)



    #2、center,ljust,rjust,zfill

    # x = "egon"

    # res=x.center(50,'*')

    # print(res)

    # print(x.ljust(50,"*"))

    # print(x.rjust(50,"*"))

    # print(x.zfill(50))

    # print(x.rjust(50,"0"))

    #3、expandtabs

    # print("hello world".expandtabs(1))

    #4、captalize,swapcase,title

    # print("hello world egon".capitalize())

    # print("aBcDeF".swapcase())

    # print("hello world egon".title())


    #5、is其他

    # name='egon123'

    # print(name.isalnum()) #字符串由字母或数字组成

    # print(name.isalpha()) #字符串只由字母组成

    #

    # name="aaainputbbbbb"

    # print(name.isidentifier())

    # name="abc123"

    # print(name.islower())

    # print(name.isupper())

    # name="     "

    # print(name.isspace())

    # name="My Name Is Egon"

    # print(name.istitle())

    #6、is数字系列
    #在python3中
    num1=b'4' #bytes
    num2=u'4' #unicode,python3中无需加u就是unicode
    num3='四' #中文数字
    num4='Ⅳ' #罗马数字

    #1、 bytes、unicode

    # print(num1.isdigit())

    # print(num2.isdigit())

    # print(num3.isdigit())

    # print(num4.isdigit())


    # 2、unicode、中文数字、罗马数字

    # print(num2.isnumeric())

    # print(num3.isnumeric())

    # print(num4.isnumeric())

    # 3、unicode

    # print(num2.isdecimal())

    # print(num3.isdecimal())

    # print(num4.isdecimal())


    # ======================================该类型总结====================================

    # 存一个值

    # 有序

    # 不可变

    # x="hello"

    # x[0]="H"

    CCC列表类型

    # ======================================基本使用======================================

    # 1、用途:按照索引存放多个任意类型的值,索引反映的是位置/顺序

    # 2、定义方式:在[]内用逗号分割开多个任意类型的元素

    # l=[111,1.1,"aaa",[2222,3333]] # l=list([111,1.1,"aaa",[2222,3333]])

    # print(type(l))

    # 数据类型转换

    # res=list("hello")

    # res=list({"k1":1,"k2":2,"k3":3})

    # print(res)

    # 3、常用操作+内置的方法

    # ===============3.1 优先掌握的操作:

    #1、按索引存取值(正向存取+反向存取):即可以取可以改值,不能加值
    l1 = [11,22,33,44,55]

    # print(l1[0])

    # print(l1[10])

    # print(l1[-1])

    # print(id(l1))

    # l1[0] = 100

    # print(id(l1))

    # l1[5] = 11111

    # d = {'k1':2}

    # d['kkkk']=22222

    # print(d)

    #2、切片(顾头不顾尾,步长)
    l1 = [11,22,[66,77]]

    # res=l1[2:4]

    # print(res)

    # print(l1)

    # 2.1 浅copy:

    # l2=l1[:]

    # l2=l1.copy()

    #

    # print(id(l1[0]),id(l1[1]),id(l1[2]))

    # print(id(l2[0]),id(l2[1]),id(l2[2]))




    # l1[0] = "aaa"

    # l1[1] = "bbb"

    # l1[2] = "ccc"

    # l1[2][0] = 8888

    # print(l2)


    # from copy import deepcopy

    # l3=deepcopy(l1)

    # print(id(l3[0]),id(l3[1]),id(l3[2]))

    #

    # l1[2][0]=6666

    # print(l1)

    # print(l3)

    # 示范1:

    # l1[0]=1000

    # print(l1)

    # print(l2)

    # 示范2:

    # l1[-1][0]=666

    # print(l1)

    # print(l2)

    # 了解:

    # res=l1[-1:-4:-1]

    # res=l1[::-1]

    # print(res)


    #3、长度

    # l1 = [11,22,[66,77]]

    # print(len(l1))

    #4、成员运算in和not in

    # l1 = [111,22,[66,77]]

    # print([66,77] in l1)

    # print(66 in l1)

    # print(66 not in l1)

    #5、追加
    l1=[11,222]

    # l1.append(33)

    # l1.append(44)

    # l1.append([55,66])

    # print(l1)

    # l1.insert(1,"aaa")

    # print(l1)

    #6、删除
    l1=[11,222,[1,2]]
    #6.1 万能删除,没有返回值,代表的是单纯的删除

    # del l1[0]

    # print(l1)

    #6.2 指定元素删除,没有返回值,代表的是单纯的删除

    # res=l1.remove([1,2])

    # print(l1)

    # print(res)

    #6.3 指定索引删除,有返回值,代表的是取走操作

    # res=l1.pop(1)

    # print(l1)

    # print(res)

    #7、循环

    # l1=[11,222,[1,2]]

    # for x in l1:

    #     print(x)


    # ===============3.2 需要掌握的操作:

    l1=[11,22,333,333,333,]

    # l1.clear()

    # print(l1)

    # print(l1.count(333333333))

    # l2=[444,555]

    # for item in l2:

    # #     l1.append(item)

    # l1.extend(l2)

    l1.extend("hello")
    print(l1)

    # l1=[11,22,333,333,333,]

    # res=l1.index(333,0,2)

    # res=l1.index(444)

    # print(res)

    # l1=[11,22,"aaa",'bbb']

    # l1.reverse()

    # l1=l1[::-1]

    # print(l1)

    # l1 = [11, 22, "aaa", 'bbb']

    # l1 = [-3,99,12,-5,93]

    # l1.sort(reverse=True)

    # print(l1)

    # ======================================该类型总结====================================

    # 存一个值or存多个值

    # 有序or无序

    可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)

    ddd 元组类型

    # 什么是元组?

    # 元组就是一个不可变的列表

    #

    # ======================================基本使用======================================

    # 1、用途: 按照索引存放多个任意类型的值,索引反应的是位置/顺序

    # 2、定义方式:在()内用逗号分隔开多个任意类下的值/元素

    # t=(10)

    # print(type(t))

    # 强调:当元组内只有一个元素时,必须加逗号

    # t=(10,)

    # print(type(t))

    # t=(10,1.1,"aaa",[11,22])

    # print(t[-1][0])

    # t[0]=11111

    # t[-1]=333333

    # t=(11,22,[33,44])

    # print(id(t[0]),id(t[1]),id(t[2]))

    #

    # t[2][0]=333333333

    # # print(t)

    # print(id(t[0]),id(t[1]),id(t[2]))

    # t=(11,22) # t=tuple(...)

    # print(type(t))

    # 类型转换

    # tuple(所有可以被for循环遍历的类型)

    # t=()

    # print(t)

    # print(type(t))

    # 3、常用操作+内置的方法

    #优先掌握的操作:
    #1、按索引取值(正向取+反向取):只能取

    # t=(10,1.1,"aaa",[11,22])

    # print(t[0])

    #2、切片(顾头不顾尾,步长)

    # t=(11,22,33,44,55)

    # print(t[0:3])

    #3、长度

    # t=(11,22,33,44,55)

    # print(len(t))

    #4、成员运算in和not in

    # t=(11,22,33,44,55)

    # print(11 in t)

    #5、循环

    # for x in t:

    #     print(x)


    #需要掌握的操作:

    # t=(11,22,33,44,55)

    # ======================================该类型总结====================================

    # 存多个值

    # 有序

    不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)

    eee 字典类型

    # ======================================基本使用======================================

    # 1、用途:按key:value的形式存放多个任意类型的value,key反映的是value的属性

    # 2、定义方式:在{}内用逗号分隔开多个key:value,其中value可以是任意类型

    #           而key必须是不可变的类型,通常是字符串类型

    # d={'k1':111,'k1':222,'k1':3333} # key重复,只保留一个

    # print(d)


    # d={1:"aaa",3.1:'bbbb',[1,2]:"ccc"}

    # d={1:"aaa",3.1:'bbbb',():"ccc"} # d=dict(...)

    # print(type(d))

    # print(d[()])

    # 类型转换

    # l=[("name","egon"),("age",18),["gender","male"]]

    # res=dict(l)

    # print(res)

    # d=dict(x=1,y=2,z=3)

    # print(d)

    # 空字典

    # d={}

    # print(type(d))

    # dic={}.fromkeys(["name",'age',"gender"],None)

    # dic={}.fromkeys("hello",None)

    # print(dic)


    # 3、常用操作+内置的方法

    #==========>优先掌握的操作:
    #1、按key存取值:可存可取

    # d={'k1':111}

    # print(d['k1'])

    # d['k2']=222

    # print(d)

    #2、长度len

    # d={'k1':111,'k2':222}

    # print(len(d))


    #3、成员运算in和not in

    # d={'k1':111,'k2':222}

    # print('k1' in d)

    # print(111 in d)


    #4、删除
    d={'k1':111,'k2':222}
    #6.1 万能删除,没有返回值,代表的是单纯的删除

    # del d['k1']

    # print(d)

    #6.2 随机删,返回一个元组

    # res=d.popitem()

    # print(d)

    # print(res)

    #6.3 指定key删除,有返回值,代表的是取走操作

    # res=d.pop('k1')

    # print(d)

    # print(res)

    #5、键keys(),值values(),键值对items()
    """

    >>> d={'k1':111,'k2':222}
    >>> d.keys()
    >>> ['k2', 'k1']
    >>> d.values()
    >>> [222, 111]
    >>> d.items()
    >>> [('k2', 222), ('k1', 111)]
    >>> """

    #6、循环

    # d={'k1':111,'k2':222}

    # for k in d:

    #     print(k)

    # for v in d.values():

    #     print(v)

    # for k,v in d.items():

    #     print(k,v)

    # keys=[]

    # for k in d:

    #     keys.append(k)

    keys=list(d.keys())
    print(keys)

    # ======================================该类型总结====================================

    # 存一个值or存多个值

    # 有序or无序

    # 可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)

    fff 集合及一些补充知识

    # t = (1)

    # print(t,type(t))

    # """

    # 推荐你们在使用容器类型的元素的时候

    # 如果该容器类型只有一个元素 那么你也习惯性的

    # 将逗号加上

    # t = (1,)

    # l = ['jason',]

    # """

    # d = dict(username='jason', age=18)

    # print(d) # {'username': 'jason', 'age': 18}

    # 类型转换

    # d1 = dict([['username','password'],('jason',123)])

    # print(d1) # {'username': 'password', 'jason': 123}

    # 操作方法

    # 取值

    """
    字典默认暴露给外界的可操作的只有字典的key
    字典是无需的 根本没有索引一说

    程序员第一准则
      能少写一个字母绝对不多写一个
    """
    d = {'username': 'jason', 'password': 123}

    # print(d['username']) # 不推荐使用该方法

    # print(d['xxx']) # KeyError: 'xxx'

    # 1 get方法

    # res = d.get('username')

    # print(res) # jason

    # res = d.get('xxx')

    # print(res) # None 键不存在会返回None 不会报错

    # res = d.get('username', '你搞什么飞机 这个键不存在 去你妹啊')

    # print(res) # 键存在还是返回对应的值

    # res = d.get('xxx', '你搞什么飞机 这个键不存在 去你妹啊')

    # print(res) # 键不存在 返回get方法里面第二个参数

    # 字典新增键值对

    # 方式1

    # d['hobby'] = 'study' # 字典的key不存在新增

    # print(d)

    # d['username'] = 'egon'

    # print(d) # 字典的key存在则修改

    # 方式2

    # d.update(username='jason')

    # print(d) # 特点同上

    # 方式3

    """
    键如果存在的情况下 那么不做修改 而是将对应的value取出
    键如果不存在的情况下 那么就是新增
    """

    # d.setdefault('xxx',123)

    # print(d) # 键不存在是新增

    # res = d.setdefault('username',123)

    # print(d) # {'username': 'jason', 'password': 123}

    # print(res) # jason

    # 快速构造字典

    # res = {}.fromkeys(['k1','k2','k3'],[])

    # # print(res) # {'k1': [], 'k2': [], 'k3': []}

    # res.get('k1').append(123)

    # print(res)

    """
    A
    {'k1': [123], 'k2': [], 'k3': []}
    B
    {'k1': [123], 'k2': [123], 'k3': [123]}
    C
    报错
    D
    我TMD的也不知道
    """

    # 弹出

    # res = d.pop('username') # 将括号内指定的key对应的value弹出

    # print(d,res) # jason

    # res1 = d.popitem() # 将弹出的键值对组织成元组的形式返回出去

    # print(d,res1) # {'username': 'jason'} ('password', 123)


    # 字典方法三剑客

    # print(d.keys()) # 获取字典所有的key

    # print(d.values()) # 获取字典所有的value

    # print(d.items()) # 获取字典所有的key和value组织成小元组

    """
    可以直接只看里面的数据结构
    dict_keys(['username', 'password'])
    dict_values(['jason', 123])
    dict_items([('username', 'jason'), ('password', 123)])
    """

    # for key in d.keys():

    #     print(key)

    # for value in d.values():

    #     print(value)

    # for item in d.items():

    #     print(item)

    # for k, v in d.items():

    #     print(k,v)

    # 清空

    # d.clear()

    # print(d)

    # __class__ # 双下class

    # s = {1,2,3,4,5,6,7,8}

    # print(type(s))

    # s1 = {}

    # d1 = {}

    # print(type(s1),type(d1)) # <class 'dict'> <class 'dict'>

    # # 定义空集合一定要用set关键字

    # ss = set()

    # print(ss,type(ss)) # set() <class 'set'>


    # s = {1,1,1,2,3,3,4,3,2,3,4,6,5,3,}

    # print(s)

    # 类型转换

    # s1 = set('egon is o DSB')

    # print(s1)

    # s2 = set([1,2,3,4,5,6,7,7,7,7,7])

    # print(s2)

    # s3 = set({'username':'jason','password':123})

    # print(s3) # {'password', 'username'}

    l = [4,3,2,3,4,6,7,8,1,2,3]

    # # 先转成集合

    # s = set(l)

    # # 再转成列表

    # l1 = list(s)

    # print(l1)

    # new_l = []

    # for i in l:

    #     if i not in new_l:

    #         new_l.append(i)

    # print(new_l)


    # 用户1的好友列表

    friends1 = {'jason','tank','tony','jerry'}

    # 用户2的好友列表

    friends2 = {'jason','tony','owen','oscar'}

    # 1 求两个用户的共同好友 交集

    # res = friends1 & friends2

    # print(res) # {'jason', 'tony'}

    # 2 求两个用户所有的好友

    # res = friends1 | friends2

    # print(res) # {'jerry', 'jason', 'oscar', 'tony', 'tank', 'owen'}

    # 3 求用户1独有的好友

    # res1 = friends1 - friends2

    # res2 = friends2 - friends1

    # print(res1,res2) # {'jerry', 'tank'} {'owen', 'oscar'}

    # 4 求两个用户各自独有的好友           对称差集

    # res = friends1 ^ friends2

    # print(res) # {'owen', 'jerry', 'tank', 'oscar'}

    # 5 子集 父集

    s1 = {12,3,4,5,6}
    s2 = {12,6}
    print(s1 > s2) # s1是否是s2的父集
    print(s2 < s1) # s2是否是s1的子集

     

    每天逼着自己写点东西,终有一天会为自己的变化感动的。这是一个潜移默化的过程,每天坚持编编故事,自己不知不觉就会拥有故事人物的特质的。 Explicit is better than implicit.(清楚优于含糊)
  • 相关阅读:
    MySql为查询结果添加前、后缀
    SQLHelper类
    OracleHelper类
    C#在sql中使用變量訪問Oracle數據庫
    转-调用HTMLTestRunner生成的报告中不能显示用例中print函数的输出
    HTMLTestRunner优化:带截图、饼图、失败重跑
    【转】如何成功安装旧版本火狐,成功安装firebug和firepath插件
    【转】Selenium 加载Chrome/Firefox浏览器配置文件
    mac查看python安装路径
    requests模拟上传照片
  • 原文地址:https://www.cnblogs.com/kylin5201314/p/13540401.html
Copyright © 2020-2023  润新知