基本数据类型及常用操作和内置方法

一、int整型

作用：记录整数状态的事物，如：年龄、号码人数等
定义方式：int 可以将纯数字的字符串转化成整型（两边可以有空格，中间不行）
age = 18

常用操作和内置方法：算术运算 + 比较运算

二、float浮点型

作用：记录薪资、身高、体重等
float 可以将浮点型数字组成的字符串转化成浮点型
salary = 4.5

常用操作和内置方法：算术运算 + 比较运算

三、字符串及其操作

作用：记录描述性质的状态，如：姓名、住址等
在引号（' '、" "、''' '''、""" """）内包含一串或者多行字符串
数据类型转换：str（）可以把任意类型转换成字符串类型

• 常用操作+内置的方法（重点掌握）

（1）按索引取值（正向取、反向取，不可改）
s = "hello"
print(s(0))
print(s(-1))

（2）切片操作：顾头不顾尾，有步长，属于拷贝操作，不改变原值的id
msg = 'hello world' 
print(msg[0:4])　# hell        默认步长为1，取第1到第4个字符, 原字符串不变
print(msg[:6:2]) # hlo         省略起始位置，默认起始位置为0
print(msg[::2])  # hlowrd      省略结束位置，默认一直到末尾全部都取到
print(msg[::])   # hello world 可简写成print(msg[:])  省略步长，默认步长为1

（3）长度len()
msg = 'hello'
print(len(msg))

（4）成员运算in 、 not in
msg = "hello 你好"
print("你好" in  msg)
print("你好" not in msg) # 语义明确，推荐使用
# print(not "你好" in msg) # 不推荐使用

（5）strip
a. 移除空白
msg = '   hello  \n  '
res1 = msg.strip()  # 默认移除两边的空白字符，包括\n 和 \t，不改变原来的msg

b. 移除两边非空白字符
msg = "==hello!()"
res = msg.strip("()=!")
print(res)　　　　# 得到的是新字符串，不改变原来的msg

（6）切分split：将字符串按照某个分隔符切分成一个列表
msg = "a:b:c:d"        # 字符串按冒号有规律的分布
res = msg.split(':')
print(res)　　　　      #  ['a', 'b', 'c', 'd']

（7）循环（可以被for循环遍历）
for item in "hello":
	print(item)

• 需要掌握的操作

（1）strip,lstrip,rstrip
msg = "*****hello*****"
print(msg.strip('*'))    # hello       去除两边的*号
print(msg.lstrip('*'))   # hello*****  去除左边的*号
print(msg.rstrip('*'))   # *****hello  去除右边的*号

（2）lower、upper、(swapcase)
msg = "aABb"
print(msg.lower())  # aabb  所有字母全部小写
print(msg.upper())  # AABB  所有字母全部大写
print(msg.swapcase()) # AabB 所有的字母大小写反转

（3）startswith、endswith （返回布尔值）
msg = "tomorrow is Tuesday"
print(msg.startswith("to"))   # True 判断是否是以to开头
print(msg.endswith("y"))    # True 判断是否是以y结尾

（4）format三种用法
以下代码均可实现格式化输出"my name is jason，age is 18"
# ① %s的方式
print("my name is %s, age is %s" % ("jason", 18))

# ② format的方式
print("my name is {}, age is {}".format("jason", 18))
print("my name is {x}, age is {y}".format(y=18, x="jason"))
print("my name is {0}, age is {1}".format("jason", 18))  # 按照位置

# ③ f''的方式
x = 'jason'
y = 18
print(f"my name is {x}, age is {y}")  #python3.6版本及之后支持
了解：① f 搭配{}可以执行字符串中的代码
② f 包含的字符串可以放到多行
③ {}内不能有#和/

（5）split、rsplit
msg = 'a: b: c: d'
print(msg.split(':',1))   # ['a', 'b: c: d]  正向分割一次
print(msg.rsplit(':',1))  # ['a: b: c', 'd'] 反向分割一次

（6）join
l = ['a', 'b', 'c', 'd']
print("-".join(l))   # a-b-c-d

（7）replace
msg = 'cc cc cc'
print(msg.replace('cc', 'CC', 2))   # CC CC cc  （将前两个"cc"替换成"CC"）
print(msg.replace('cc','c'))  # c c c (将所有的cc都替换成c)

（8）isdigit：判断字符串是否是由纯数字组成的
age = " 18**"
print(age.isdigit())  # False (必须纯数字才是True，小数点、空格都不能有)

• 了解级别的操作

（1）find、rfind、index、rindex、count
（2）center、ljust、rjust、zfill
（3）extendtab
（4）is数字系列 isdigit、isdemical、isnumberic
（5）is其他： isalpha、isalnum

• str类型总结：

    （1）只能存一个值
    （2）有序
    （3）属于不可变类型
  

四、列表及其操作

• 重点掌握的操作

（1）按索引取、改值（正、反向存取）
	可以改也可以取值，但是超出索引会报错（即不可以使用这种非操作来为列表增加值）
l = [111, 222]
l[0] = 123  # 可以对列表可以被素引到的值进行修改
print(l)  # [123, 222]

（2）切片 ：顾头不顾尾，有步长
l = [111, 222, 333, 444]
l1 = l[0:3]
print(l1)     # [111, 222, 333]

l2 = l[::-1]  # 反向存值,可以指定起始、终点位置
print(l2)  # [444, 333, 222, 111]

（3）len 长度 ：即列表存的值的个数
l = [111, 222, 333, [444, 555]]
print(len(l))  # 4

（4）成员运算in 、not in
l = [111, 222, 333]
print(111 in l)        # True
print(111 not in l)    # False

（5）追加
	① append 可以在列表末尾加一个值
l = [111, 222, 333, 444, 555]
l.append(666)
l.append(777)  
print(l)      # [111, 222, 333, 444, 555, 666, 777]

	② insert 可以在指定位置前增加一个值
l = [111, 222, 333, 444, 555]
l.insert(0, 123)    # (在索引0前增加一个值)
print(l)            # [123, 111, 222, 333, 444, 555]  

（6） 删除
	① del是通用的、不是列表专属的删除方式
l=[111,"aaa",222,333,444,555]
del l[0]
print(l)      # >>> ['aaa', 222, 333, 444, 555]

	② 列表专属的删除方式之指定元素删除
l=[111, "aaa", "aaa", 222, 333, 444, 555]
res=l.remove("aaa")  # 指定元素删除，每次删除一个
print(l)      # [111, "aaa", 222, 333, 444, 555]
print(res)    # None

	③列表专属的删除方式之指定索引删除
l = [111, "aaa", 222, 333, 444, 555]
res = l.pop()  # 默认删除的是索引-1对应的值,有返回值 555
print(l)       # [111, 'aaa', 222, 333, 444]
print(res)     # 555

（7）可以被 for循环 遍历
for i in [111, 222, 333]:
	print(i)

• 需要掌握的操作

（1）count ： 统计某个值在列表中的个数
l=[11, 22, 11, 11]
print(l.count(11))  # 3

（2）sort ：排序，sort 只能在存有能比较大小的值的列表中使用
l = [10, -1, 3, 2, 11]
l.sort(reverse=True)  # reverse = True表示从大到小排列
print(l)    # [11, 10, 3, 2, -1]

（3）clear ：清空列表
l = [1,2,3]
l.clear()
print(l)  # []

（4） reverse ：反向重排
l = ['benz', 'audi', 'bmw']
l.reverse()
print(l)  # ['bmw', 'audi', 'benz']

（5）extend ： 追加多个值 （append、insert都只能追加一个值）
l = [11, 22, 33]
l.extend([44, 55, 66])
print(l)    # >>>[11, 22, 33, 44, 55, 66]

（6） 深浅copy
	① 浅copy
	拷贝的值如果有可变类型的，更改原列表的可变类型元素，copy的列表也会跟着变
	与因为拷贝的是原来值的内存地址
l1 = [11, 22, [33, 44]]
l2 = l1.copy()
l1[-1][0] = 'hello'
print(l1)  # [11, 22, ['hello', 44]] 
print(l2)  # [11, 22, ['hello', 44]]

	②深copy
	更改原列表的可变类型元素，copy的列表则不会跟着变
	因为深copy会将拷贝来的可变类型重新绑定一个新的内存地址
from copy import deepcopy

l1 = [11, 22, [33, 44]]
l2 = deepcopy(l1)
l1[-1].append(555)
print(l1)  # [11, 22, [33, 44, 555]]
print(l2)  # [11, 22, [33, 44]] 不跟随l1改变

• 类型总结

    可以存多个值
    有序
    属于可变类型
  

五、元组及其操作

• 用途：

按照索引存放多个任意类型的值，索引反映的是位置/顺序
本质上元组就是不可变的列表

• 定义：

在小括号()内用逗号分隔开多个任意类型的值
t = (111, 222, 333)  # t=tupe((111,222,333))
t = ()  # 定义空

• 强调：（1）当元组内只有一个元素时，必须加逗号

t = ("aaa"，)

• 类型转换

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

• 常用操作及内置方向

（1）按素引取值
只能取不能改
可以正、反向取

（2）切片 ： 顾头不顾尾，有步长
t = (11, 22, 33)
print(t[::-1])  # (33, 22 11)

（3）len ：长度
t = (111, 222, 333)
print(len(t))　　# 3

（4）成员运算in 、not in
t = (111, 222, 333)
print(111 in t)　　# True

（5）for循环
for i in (11, 22, 33)
	print(i)

• 需要掌握的操作
  index、count

l1 = (111, 222, 333, 444, 111)
print(l1.index(333))  # 2
print(l1.count(123))  # 0

• 类型总结

    可以存多个值
    不可变
    有序
  

六、字典及其操作

• 作用：

    按key:value的形式存放多个任意类型的value，key反映的是value的属性
    存多个不同属性的值，用key对应value，key必须是不可变类型
  

• 定义方式

    在{ }内用逗号分隔开多个key:value元素，其中key必须是不可变类型，并且key不可以重复
    而value可以是任意类型
    d={"k1":1111,"k2":222}  # d=dict({"k1":1111,"k2":222})
  

定义空

dic = {}

• 类型转换

    dict()可以将一组两两对应的值转化成字典
  

l=[("name","jason"),("age",18),["gender","male"]]
d1=dict(l)
print(d1)n  # {'name': 'jason', 'age': 18, 'gender': 'male'}

d2=dict(x=11,y=22,z=33)
print(d2)  # {'x': 11, 'y': 22, 'z': 33}

• 优先掌握的常用操作

（1） 按key存取值：可存可取
d = {'name': 'jason', 'age': 18}
print(d['age'])       # >>>18
d['gender'] = 'male'  # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果,而列表不行
print(d)     　　　　　 # >>>{'name': 'jason', 'age': 18, 'gender': 'male'}

（2）len 长度
d = {'name': 'jason', 'age': 18}
print(len(d))  # 2

（3）成员运算in 、not in  ：只能判断key，不能判断value
d = {'name': 'jason', 'age': 18}
print('name' in d)  # True

（4）删除
	① del 万能删除 （没有返回值，单纯只是删除）
d = {'name': 'jason', 'age': 18}
del d['name']
print(d)  # {'age': 18}

	② popitem 随机删除（有返回值，本质上是取走操作）
d = {'name': 'jason', 'age': 18}
res = d.popitem()  # 随机删除一组 key:value，并组织成元组的形式返回
print(res)  # ('age', 18)

③ pop 指定删除（有返回值，本质上是取走操作）
d = {'name': 'jason', 'age': 18}
res = d.pop('name')  # 将括号内指定的key对应的value弹出
print(res)  # jason

（5）键keys()，值values()，键值对items()
以python2中使用为例，keys()、values()、items()可以对字典取键、值、键值对，以列表形势返回
>>> d={"name":"jason",'age':18}
>>> d.keys()
['age', 'name']
>>> d.values()
[18, 'jason']
>>>
>>> d.items()
[('age', 18), ('name', 'jason')]

（6）字典可以用于for循环
d = {'name': 'egon', 'age': 18}
for k in d:    # 同样的，d.keys()、d.values()、d.items()也可以用于for循环
    print(k)

• 内置的方法

（1）clear 清空字典

（2）update 新增键值对,可以增加，可以修改（如果key存在，那么将值修改成后update传入的）
d = {'k1': 111, 'k2': 222 }
d.update(k2='aaa', k3=333)  # 可增可改
print(d)  # {'k1': 111, 'k2': 'aaa', 'k3': 333}

（3）get ① 查找  （优点：查找的key不存在不会报错，而是返回None）
d = {'name': 'jason', 'age': 18}
print(d.get('name'))  # key不存在不会报错，会返回None
print(d["name"])      # key不存在则会报错
	② get()也可以传自定义的参数，用作找不到后的返回值
d = {'name': 'jason', 'age': 18}
res = d.get('name1', '找不到')  # key不存在不会报错，会返回右边的自定义返回值
print(res)  # 找不到

• 了解即可
  （1） {}fromkeys()
  作用：快速初始化一个字典

d = {}.fromkeys(["name", "age", "gender"], None)  # 不写None结果也一样
print(d)  # {'name': None, 'age': None, 'gender': None}

（2）setdefault()
作用：保证字典中肯定有一个key是指定的，（如果原来字典有这个key，那么原字典的值不变，返回的仍然是原value）

d = {'k1': 111, 'k2': 222, }
val = d.setdefault('k3', 333)
print(d)    # {'k1': 111, 'k2': 222, 'k3': '333'}
print(val)  # 333

res = d.setdefault('k2', 123)
print(d)   # {'k1': 111, 'k2': 222, 'k3': '333'}
print(res)  # 222   返回 k2 对应的原来的 222

• 类型总结

    可变
    无序
    可以存多个值
  

七、集合及其操作

• 作用：

 ① 去重（集合内不可能出现相同的元素）
 ② 关系运算
 用集合就是用上面这两个功能，如果用不上那就不要使用集合

• 特点：

  ① 无序
  ② 元素必须是不可变元素
  ③ 元素不能重合

• 类型转换

    能够被for循环遍历的类型都可以被转换成集合
  

ss = set('hello')
print(ss)  # {'l', 'o', 'h', 'e'}
res = ''.join(ss)
print(res)  # lohe

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

s = set()

• 常用操作
  对于下面s1和s2两个集合做一些操作

s1 = {'aaa', 'bbb', 'ccc', 'ddd'}
s2 = {'ccc', 'ddd', 'eee', 'fff'}

① 求交集
res = s1 & s2
print(res)  # {'ddd', 'ccc'}

② 求并集
res = s1 | s2
print(res)  # {'aaa', 'ccc', 'eee', 'ddd', 'bbb', 'fff'}

③ 求差集
res = s1 - s2
print(res)  # {'bbb', 'aaa'}

④ 求交叉补集
res = s1 ^ s2
print(res)  # {'eee', 'bbb', 'fff', 'aaa'}

⑤ 父、子集 ：（一个集合包含另一个集合才会有）
s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2)  # True，代表s1是s2的父集
print(s2 < s1)  # True，代表s2是s1的子集

• 常用操作

（1）循环
for item in {1,2,3}:
	print(item) 

（2）update ： 括号里面的对象必须可以被for循环遍历（列表、元组、字符串等，字典只能往集合里增加key，字符串会被拆成一个个“字符”）
s1 = {333, 222, 111}
s1.update({'aaa', 'bbb'})
print(s1)  # {'aaa', 'bbb', 333, 222, 111}

（3）clear ：清空集合，得到空集合 set()

（4）pop  ：随机删除 （返回值为删除的那个值）
ss = {1,2,3}
res = ss.pop()
print(ss)  # {1, 3}
print(res)  # 2

（5）remove ：指定元素删除（返回值为None）
ss = {1,2,3}
res = ss.remove(3)
print(ss)  # {1, 2}
print(res)  # None

（6）discard ：指定元素删除，返回值为None （与remove不同的是，如果指定的元素不存在，不会报错）
s1 = {333, 222, 111}
res = s1.discard("aa")
print(s1)  # {333, 222, 111}   与remove不同的是，如果删除的值不存在，运行不会报错
print(res)  # None

（7）add ：只能添加一个值，添加多个值会报错
s1 = {333, 222, 111}
s1.add("aaa")
print(s1)  # {'aaa', 333, 222, 111} 

（8）isdisjoint ：判断两个集合是否为没有交集，若没有就返回True，有交集就返回False
用法：s1.isdisjoint(s2)
s1 = {333, 222, 111}
s2 = {"aaa", "bbb"}
print(s1.isdisjoint(s2))  # True

• 集合类型总结

    无序
    能存多个值
    set集合属于可变类型
  

八、bool 布尔型

• 作用

    可以记录真、假两种状态
  

布尔型只有True和False两个值
布尔型可以被定义赋值给变量，也可以通过逻辑运算得到：
tag = True
print(10 <= 11)  # >>>True

本文地址：https://blog.csdn.net/weixin_49111957/article/details/107349358