欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-12 15:39:17
基本数据类型及常用操作一、int整型二、float浮点型三、字符串及其操作二、列表及其操作三、元组及其操作四、字典及其操作五、集合及其操作一、int整型作用:记录整数状态的事物,如:年龄、号码人数等定义方式:int 可以将纯数字的字符串转化成整型(两边可以有空格,中间不行)age = 18常用操作和内置方法:算术运算 + 比较运算二、float浮点型作用:记录薪资、身高、体重等float 可以将浮点型数字组成的字符串转化成浮点型salary = 4.5常用操作和内置方法:算术运算...

一、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[:])  省略步长,默认步长为13)长度len()
msg = 'hello'
print(len(msg))4)成员运算innot 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)    # 得到的是新字符串,不改变原来的msg6)切分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结尾4format三种用法
以下代码均可实现格式化输出"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-d7)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
(4is数字系列 isdigit、isdemical、isnumberic
(5is其他: 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]3len 长度 :即列表存的值的个数
l = [111, 222, 333, [444, 555]]
print(len(l))  # 44)成员运算innot in
l = [111, 222, 333]
print(111 in l)        # True
print(111 not in l)    # False5)追加
	① 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)     # 5557)可以被 for循环 遍历
for i in [111, 222, 333]:
	print(i)
  • 需要掌握的操作
1)count : 统计某个值在列表中的个数
l=[11, 22, 11, 11]
print(l.count(11))  # 32)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)3len :长度
t = (111, 222, 333)
print(len(t))  # 34)成员运算innot in
t = (111, 222, 333)
print(111 in t)  # True5for循环
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'}2len 长度
d = {'name': 'jason', 'age': 18}
print(len(d))  # 23)成员运算innot in  :只能判断key,不能判断value
d = {'name': 'jason', 'age': 18}
print('name' in d)  # True4)删除
	① 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)  # jason5)键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)  # 25)remove :指定元素删除(返回值为None)
ss = {1,2,3}
res = ss.remove(3)
print(ss)  # {1, 2}
print(res)  # None6)discard :指定元素删除,返回值为None (与remove不同的是,如果指定的元素不存在,不会报错)
s1 = {333, 222, 111}
res = s1.discard("aa")
print(s1)  # {333, 222, 111}   与remove不同的是,如果删除的值不存在,运行不会报错
print(res)  # None7)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 布尔型

  • 作用

      可以记录真、假两种状态
    
布尔型只有TrueFalse两个值
布尔型可以被定义赋值给变量,也可以通过逻辑运算得到:
tag = True
print(10 <= 11)  # >>>True

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