python 数据类型是object python数据类型的作用

1：整数类型（int）
1：用途
int:记录年龄,等级,岁月等
2：定义方式
>>> x = 10
>>> id(x)
1489303616
>>> type(x)
2：浮点数类型（float）
1：用途
float:记录重量，工资等
2：定义方式
>>> x = 1.5
>>> y = 8.8
>>> type(x)
3：数据类型之间转换
>>> age = "134423"
>>> print(type(age))
>>> age = int(age)
>>> type(age)
警告
纯数字类型字符串可以通过int方法转换成数字类型
>>> salary = "2.5"
>>> type(salary)
>>> salary=float(salary)
>>> salary
2.5
>>> type(salary)
>>>
警告
纯浮点类型字符串可以通过float方法转换成浮点类型
4:字符串类型(str)
1：用途
主要是用来描述事物特征的
2:定义方式
x = "x"
1 2 3
1:是变量名
2:是赋值符号
3:值用"content","""content""","""content"""
3:str方法
一:根据索引取值
1:正向取值
>>>msg = "hello小白兔"
>>>msg
"hello小白兔"
索引从0开始
>>>msg[0]
"h"
>>>msg[1]
"e"
2：反向取值
索引从-1开始
"hello小白兔"
>>> msg[-1]
"兔"
>>> msg
"hello小白兔"
>>> msg[-1:-6]
""
>>> msg[-3]
"小"
>>> msg[-13]
Traceback (most recent call last):
File "", line 1, in 
IndexError: string index out of range
超过范围，报错
3:步长
>>> msg
"hello小白兔"
>>> msg[0:5:2]
"hlo"
>>>
用步长方向取值
>>> msg[:]
"hello小白兔"
>>> msg[::-1]
"兔白小olleh"
二:切片取值（左闭右开）
1:正常从左向右
>>> msg
"hello小白兔"
>>> msg[2:]
"llo小白兔"
>>> msg[:]
"hello小白兔"
>>> msg[1:]
"ello小白兔"
>>> msg[1:4]
"ell"
2:反向取值
> msg
>>> msg[4:0:-1
... ]
"olle"
>>> msg[7:5:-1]
"兔白"
>>> msg[7:4:-1]
"兔白小"
三:长度
msg="hello小白兔"
>>> msg
"hello小白兔"
>>> len(msg)
8
四:成员运算（in，not in)
>>> msg
"hello小白兔"
>>> "h" in msg
True
>>> "aaa" in msg
False
>>> "ee" in msg
False
>>> "alex" in msg
False
>>> "a" not in msg
True
>>>
5:非常重重要（split,strip)
split方法
>>> msg
"hello小白兔"
>>> msg.split("小")
["hello", "白兔"]
>>> msg.split("o")
["hell", "小白兔"]
>>> msg.split("l")
["he", "", "o小白兔"]
>>>
strip方法
>>> msg = " hello小白兔"
>>> msg1 = "hello小白兔 "
>>> msg3 = " hello小白兔 "
>>> msg4 = " hello 小白兔 "
>>> msg
" hello小白兔"
>>> msg1
"hello小白兔 "
>>> msg3
" hello小白兔 "
>>> msg4
" hello 小白兔 "
>>>
>>>
>>> msg1
"hello小白兔 "
>>> msg1.strip()
"hello小白兔"
>>> msg1
"hello小白兔 "
>>> msg3
" hello小白兔 "
>>> msg3.strip()
"hello小白兔"
>>> msg4
" hello 小白兔 "
>>> msg4.strip()
"hello 小白兔"
>>>
7：重要方法
1、strip,lstrip,rstrip
>>> msg = " hellowstrip "
>>> msg.strip()
"hellowstrip"
>>> msg.lstrip()
"hellowstrip "
>>> msg.rstrip()
" hellowstrip"
>>>
2、lower,upper
>>> msg = "Alex"
>>> msg.lower()
"alex"
>>> msg.upper()
"ALEX"
>>>
3、startswith,endswith
>>> msg
"Alex"
>>> msg.startswith("al")
False
>>> msg.startswith("A")
True
>>> msg
"Alex"
>>> msg.endswith("x")
True
>>> msg
"Alex"
>>> msg.endswith("x")
True
>>> msg.endswith("x", 1, 2)
False
>>> msg.endswith("e", 1, 2)
False
>>> msg.endswith("l", 1, 2)
True
>>> msg.endswith("l", 1, 2)
True
>>>
4、format
>>> "hello word: {}".format("strip")
"hello word: strip"
>>>
>>> "my name is {},age {}".format("Seven", 18)
"my name is Seven,age 18"
>>>
5、split,rsplit
>>> name = "fdsfa "
>>> name
"fdsfa "
>>> name.split("s")
["fd", "fa "]
>>>
>>> name.rsplit("f")
["", "ds", "a "]
6、join
>>> name = "sfsaf"
>>> name
"sfsaf"
>>> "-".join(name)
"s-f-s-a-f"
>>> "*".join(name)
"s*f*s*a*f"
>>>
7、replace
>>> "zero".replace("o","8")
"zer8"
>>>
8、isdigit
>>> "100".isdigit()
True
>>> "afds".isdigit()
False
>>> "110032fdf".isdigit()
False
>>>
8：了解方法
1、find,rfind,index,rindex,count
>>> name = "hello word"
>>> name.find("o",1,3) # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
-1
>>> name.index("o",1,3) # 顾头不顾尾,找不到则报错,找到了则显示索引
Traceback (most recent call last):
File "", line 1, in 
ValueError: substring not found
>>> name.count("e",3,7) # 顾头不顾尾,如果不指定范围则查找所有
0
>>> name.count("o",3,7)
1
>>>
2、center,ljust,rjust,zfill
>>> "alex".center(50,"*")
"***********************alex***********************"
>>> "alex".ljust(50,"*")
"alex**********************************************"
>>> "alex".rjust(50, "*")
"**********************************************alex"
>>> "alex".zfill(50)
"0000000000000000000000000000000000000000000000alex"
>>>
3、expandtabs
>>> "name nihao".expandtabs(2)
"name nihao"
>>> "name nihao".expandtabs()
"name nihao"
>>> "name nihao".expandtabs(3)
"name nihao"
>>> "name nihao".expandtabs(3)
4、captalize,swapcase,title
>>> name ="absfds"
>>> name.capitalize()
"Absfds"
>>> name.swapcase()
"ABSFDS"
>>> "asfD".swapcase()
"ASFd"
>>> "hello word".title()
"Hello Word"
5、is数字系列
#在python3中
num1=b"4" #bytes
num2=u"4" #unicode,python3中无需加u就是unicode
num3="四" #中文数字
num4="Ⅳ" #罗马数字
#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False
#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False
#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True
#三者不能判断浮点数
num5="4.3"
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
"""
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric
"""
6、is其他
print("===>")
name="egon123"
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())
5：列表类型
1：用途
按照位置存放多个值
2：定义方式
在[]内用逗号分隔开多个任意类型的值
l = [111, 3.1, "abc", []] #l = list(......)
print(type(l))
3:类型转换
list(传入的是可迭代数据类型)
>>> list("hello")
["h", "e", "l", "l", "o"]
>>> list(14234)
Traceback (most recent call last):
File "", line 1, in 
TypeError: "int" object is not iterable
>>> list("asfsf"
... )
["a", "s", "f", "s", "f"]
>>>
4：常用操作和内置方法
1：索引次数，取值（正向，方向):即可改也可取
>>> l = [11, 22, 33, 44, 55]
>>> l
[11, 22, 33, 44, 55]
>>> l[::-1]
[55, 44, 33, 22, 11]
>>> l[2:]
[33, 44, 55]
>>> l[1:3]
[22, 33]
>>>
>>> l[5]
Traceback (most recent call last):
File "", line 1, in 
IndexError: list index out of range
2:切片（顾头不顾尾巴，步长）
>> l = [1, 2, 3, 4, 5]
>>> l
[1, 2, 3, 4, 5]
>>> l[:]
[1, 2, 3, 4, 5]
>>> l[0:3]
[1, 2, 3]
>>> l[0]
1
>>> l[4]
5
>>>
3：长度
>>> l
[11, 22, 33, 44, 55]
>>> len(l)
5
4:成员运算in和not in
>>> l
[11, 22, 33, 44, 55]
>>> len(l)
5
>>> 11 in l
True
>>> 11 not in l
False
>>> 77 in l
False
5：追加
>
>>> l= [11, 22, 33, 44, 55]
>>> l
[11, 22, 33, 44, 55]
>>> l.append("66")
>>> l.append("abc")
>>> l
[11, 22, 33, 44, 55, "66", "abc"]
1:往指定位置插入值
>>> l
[11, 22, 33, 44, 55, "66", "abc"]
>>> l.insert(0,"aa")
>>> l
["aa", 11, 22, 33, 44, 55, "66", "abc"]
>>> l.insert(3,"bb")
>>> l
["aa", 11, 22, "bb", 33, 44, 55, "66", "abc"]
>>>
6：删除
del　删除是通用的，不是列表专属
>>> ll = [111, 222, 333, 444]
>>> ll
[111, 222, 333, 444]
>>> del ll[0]
>>> ll
[222, 333, 444]
>>>
1:pop方法
pop没有参数默认从索引-1开始删除，
>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> ll.pop()
6
>>> ll
[1, 2, 3, 4, 5]
>>> ll.pop()
5
>>> ll
[1, 2, 3, 4]
>>> ll.pop(0)
1
>>> ll
[2, 3, 4]
>>>
2：remove用法
>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> ll.remove(1)
>>> ll
[2, 3, 4, 5, 6]
>>> ll.remove(5)
>>>
7：循环
>>> ll = [1, 2, 3, 4, 5, 6]
>>> ll
[1, 2, 3, 4, 5, 6]
>>> for i in ll:
... print(i)
...
1
2
3
4
5
6
>>>
8：重要方法
# 需要掌握的操作
#count
>>> ll = [11, 22, 33, 44, 55]
>>> ll.count(11)
1
>>> ll.append(11)
>>> ll.count(11)
2
>>> ll
[11, 22, 33, 44, 55, 11]
## sort
>>>
>>> ll = [10, -1, 3, 2, 11, 7]
>>> ll.sort()
>>> ll
[-1, 2, 3, 7, 10, 11]
>>> ll.sort(reverse=True)
>>> ll
[11, 10, 7, 3, 2, -1]
>>>
##clear
>>> ll
[11, 10, 7, 3, 2, -1]
>>> ll
[11, 10, 7, 3, 2, -1]
>>> ll.clear()
>>>
#reverse
>>> ll = ["a","c",1,4]
>>> ll
["a", "c", 1, 4]
>>> ll.reverse()
>>> ll
[4, 1, "c", "a"]
>>>
# extend
>>>
>>> ll = [11, 22, 33]
>>> ll.extend(["a", "b", "c"])
>>> ll
[11, 22, 33, "a", "b", "c"]
>>> ll.append(["hehe", "good"])
>>> ll
[11, 22, 33, "a", "b", "c", ["hehe", "good"]]
## copy
l1=[11,22,33]
# l1列表内存存储
# 索引0 值11的内存地址
# 索引1 值22内存地址
# 索引2 值33内存地址
# l2=l1.copy() # 等同于l4=l1[:]
# l2列表内存存储
# 索引0 值11的内存地址
# 索引1 值22内存地址
# 索引2 值33内存地址
# l2[0]=4444
# print(l2) # [4444, 22, 33]
# print(l1) # [11, 22, 33]
>>> l1 = [11, 22, 33]
>>> l1
[11, 22, 33]
>>> id(l1)
53887432
>>> l2 = l1.copy() or l2 = l1[:]
>>> id(l2)
53887944
>>> l3 = l1
>>> id(l3)
53887432
# l3=l1
# l3[0]=4444
# print(l3)
# print(l1)
5:总结
list是能存储多个值，有序，可变
6:元组数据类型
1、用途：元组就是一个不可变的列表
2、定义方式: 在小括号()内用逗号分隔开多个任意类型的值
l = [1, 2, 3]
t = (1, 2, 3) # t = tuple((111,222,333)) or t = tuple(1,)
print(type(t))
类型转换
tuple(可迭代数据类型) # ===> 元组
list(可迭代数据类型) # ===> 列表
l1 = ["a", "b", "c", "d"]
s1 = "abcedfghijk"
print(tuple(l1))
print(tuple(s1))
3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
l2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(l2)
print(l2[0])
print(l2[-1:1:-1])
2、切片(顾头不顾尾，步长)
t = (1, 2, 3)
print(t[0:2])
print(t)
3、长度
t = (1, 222, 333)
print(len(t))
4、成员运算in和not in
t = (1, 2, 3, 4)
print(4 in t)
5、循环
t = [0, 1, 2, 3, 4]
for i in t:
print(i)
需要掌握的内置方法
index根据参数找索引
count统计参数出现的次数
t = (4, 3, 2, 4, 2, 1, 5, 8, 11, 19, 1)
print(t.index(1))
print(t.index(8)) # 找不到则报错
print(t.count(1))
7：字典数据类型
1、用途
存多个不同属性的值，用key对应value，key必修是不可变类型，key通常应该是
字符串类型，因为字符串类型对值value会有解释说明的效果
2、定义方式：
在{}内用逗号分隔开多个key:value元素，其中key必须是不可变类型，并且key不同重复
而value可以是任意类型
dic = {"k1": 1, "k2": 2, "k3": 3} # dic = dict({"k1": 1, "k2": 2, "k3":3})
print(type(dic))
d = {"k1": 1, "k2": 2, "k3": 3}
print(d)
3:类型转换
d = [("name", "egon"), ["age", 18], ("gender", "male")]
print(d)
print(dict(d))
res=dict(x=1,y=2,z=3)
print(res)
4:定义空
定义空
d={} # 定义空字典
print(type(d))
d = dict()
s=""
print(type(s))
l=[]
print(type(l))
t=()
print(type(t))
t=("abc",) # 当元组内只有一个元素时，必须加逗号
print(t)
print(type(t))
# s=set() # 定义空集合
5：常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
d={"name":"egon","age":18, "salary":4}
l=[1,2,3]
print(d["name"])
print(l[0])
d["gender"]="male" # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果
print(d)
l[3]=4 # 列表不行
2、长度len
d={"name":"egon","age":18, "gender": "male"}
print(len(d))
3、成员运算in和not in:判断的是字典的key
d={"name":"egon","age":18}
print("name" in d) # 判断的字典的key
print("egon" in d) # 判断的不是value，结果为False
4、删除
a：通用删除法
d={"name":"egon","age":18, "gender": "male"}
del d["gender"]
print(d)
b:删除-》取走
res=d.popitem() # 随机删除，返回一个删除元素的小元组
print(res)
res=d.pop("name") # 返回key对应的那一个值
print(res)
print(d)
#5、键keys()，值values()，键值对items()
"""
Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
# >>> d={"name":"egon","age":18}
# >>>
# >>> d.keys()
# ["age", "name"]
# >>> d.values()
# [18, "egon"]
# >>> d.items()
[("age", 18), ("name", "egon")]
"""
#6、循环
d={"name":"egon","age":18, "gender": "male"}
for k in d.keys():
print(k)
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items(): # k,v=("age", 18)
print(k,v)
字典需要掌握的内置方法
clear
d={"name":"egon","age":18, "gender": "male"}
d.clear()
print(d)
update
d.update(age=19,gender="male")
d.update({"age":19,"gender":"male"})
print(d)
get
print(d.get("nama")) # key不存在不会报错，会返回None
print(d["nama"]) # key不存在则报错
了解**
快速初始化好一个字典
d={}.fromkeys(["name","age","gender"],None)
print(d)
d={"age":18}
保证字典中肯定有一个key是"name"
if "name" not in d:
d["name"]="egon"
d["name"]
val=d.setdefault("name","egon")
print(d)
print(val)
8：set数据类型
1：引子
friends1=["zero","kevin","jason","egon"]
friends2=["jy","ricky","jason","egon"]
l=[]
for name in friends1:
if name not in friends2:
l.append(name)
print(l)
2：用途：
去重，关系运算
3：定义方式
在{}内用逗号分隔开多个元素，元素的特点如下：
1：无序
s1={"aaa",111,"ddd"}
print(s1)
print(s1)
print(s1)
2：元素必须是不可变类型
s1={1,2.2,"abc",(1,2),[]}
3: 集合内元素不能重复
s1={1,1,1,1,1,1,1,1,1,1,1,} # s1=set(...)
print(s1)
print(type(s1))
s2=set()
print(type(s2))
4：类型转换
set(可迭代数据类型)
res=set("hello")
print(res)
print("".join(res))
res=set([111,222,333,444,111,111])
print(res)
print(list(res))
去重
res=set([111,[222],[222],333,444,111,111])
src_l=[
{"name":"lili","age":18,"sex":"male"},
{"name":"jack","age":73,"sex":"male"},
{"name":"tom","age":20,"sex":"female"},
{"name":"lili","age":18,"sex":"male"},
{"name":"lili","age":18,"sex":"male"},
]
new_l=[]
for dic in src_l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
print(id(src_l[0]))
print(id(src_l[-1]))
3、常用操作+内置的方法
1：关系运算
>>> f1 = {1, 2, 3, 4}
>>> f2 = {3, 4, 5, 6}
1,交集:两个都有的
>>> f1 & f2
{3, 4}
2,并集:两个集合的包含
>>> f1 | f2
{1, 2, 3, 4, 5, 6}
3,取第一个人独有的元素：差集
>>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> f2-f1
{5, 6}
>>> f1-f2
{1, 2}
4、求两个集合独有的（即去掉共有的元素）:对称差集/交叉补集
>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> fs1 = f2-f1
{5, 6}
>>>fs2 = f1-f2
{1, 2}
>>>fs1|fs2
{1, 2, 5, 6}
>>> f1^f2
{1, 2, 5, 6}
5、父子集：一个集合包含另外一个集合，他们才有父子集的关系
>> f1 = {1, 2, 3, 4}
>>>f2 = {3, 4, 5, 6}
>>> f1>f2
False
>>> f2>f1
False
>>> f2==f1
False
集合1>集合2 结果True时，意味着集合1内的元素完全包含了集合2的元素
f1={1,2,3}
f2={1,2}
>>> f1={1, 2, 3}
>>> f2={1, 2}
>>> f1>f2
True
# 结果True，代表f1是f2的父集
>>>f2 < f1 # 结果True，代表s2是s1的子集
False
f1 = {1, 2, 3, 4}
f2 = {3, 2, 1, 4}
>>> f1 = {1, 2, 3, 4}
>>> f2 = {3, 2, 1, 4}
>>> f1==f2 #集合f1于f2互为父集
True
2:内置方法
1:集合for循环
>>> s = {"a", 1, 2, 4, 5, 3, "z","qq"}
>>> for i in s:
... print(i)
...
1
2
3
4
5
z
a
1,s.update()
>>> id(s)
19712456
>>> s.update({7, 8 ,11})
>>> s
{1, 2, 3, 4, 5, 7, 8, "z", 11, "a", "qq"}
>>> id(s)
19712456
>>>
2、s.clear()
>>> s
{1, 2, 3, 4, 5, 7, 8, "z", 11, "a", "qq"}
>>> s.clear()
>>> s
set()
3、s1.pop()
>>> s = {"a", 1, "z", "dd", "qq"}
>>> s.pop()
1
>>> s.pop()
"dd"
>>>
# 随机删除，把元素取走，有返回删除元素
4、s.remove() # 只是删除，没有返回元素
>>> s = {"a", "b", "c", 1, "3", 4}
{1, 4, "b", "a", "3", "c"}
>>> s.remove("aaa")
Traceback (most recent call last):
File "", line 1, in 
KeyError: "aaa"
>>> s.remove(1)
>>> s
{4, "b", "a", "3", "c"}
>>> s.remove("3")
>>> s
{4, "b", "a", "c"}
5、s.discard() # 与s.remove一样都是指定元素删除
不一样的地方：当删除的元素不存在时，s.discard不会报错，
而s.remove会报错
>>> s = {"a", "b", "c", 1, "3", 4}
>>> s.discard("ssssssssss") # 指定元素不存在则报错
>>> s
{1, 4, "b", "a", "3", "c"}
>>> s.discard("a")
>>> s
{1, 4, "b", "3", "c"}
>>> s.discard("3")
>>>
s.add()
>>> s
{1, 4, "b", "c"}
>>> s.add("a")
>>> s.add("bb")
>>> s
{1, 4, "bb", "b", "a", "c"}
>>>
s.isdisjoint(s1) # 如果s1与s2没有共同的元素则返回True
>> s
{1, 4, "bb", "b", "a", "c"}
>>> s1 = {1, 4, "bb", "b", "a"}
>>> s1
{1, 4, "bb", "b", "a"}
>>> s1.isdisjoint(s)
False
>>>
总结集合set：
存多个值
无序
set集合是可变类型