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 = " \n       hel lo \t "

# 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\tworld".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的子集

 

posted @ 2020-08-21 12:38  Οo白麒麟оΟ  阅读(142)  评论(0编辑  收藏  举报