python3 数据类型相关知识详解

简介: python3 数据类型相关知识详解

基本语法

1.在Python中严格区分大小写
2.Python中的每一行就是一条语句,每条语句以换行结束
3.Python中每一行语句不要过长(规范中建议每行不要超过80个字符)
    "rulers":[80],
4.一条语句可以分多行编写,多行编写时语句后边以\结尾  
5.Python是缩进严格的语言,所以在Python中不要随便写缩进  
6.在Python中使用#来表示注释,#后的内容都属于注释,注释的内容将会被解释器所忽略
    我们可以通过注释来对程序进行解释说明,一定要养成良好的编写注释的习惯
    注释要求简单明了,一般习惯上#后边会跟着一个空格

1. 数值

10进制的数字不能以0开头

    整型(int)
        布尔值 (True  False)
    浮点型(float)
    复数

2. 字符串

相同的引号之间不能嵌套,不能跨行

2.1 长字符串

使用三重引号来表示一个长字符串,三重引号可换行,并会保留字符串中的格式

s = '''锄禾日当午,
       汗滴禾下土'''

2.2 转义字符

2.3 拼接字符串

字符串只能和字符串拼接,不能和其他类型的进行拼接,否则会报错

2.4 在创建字符串时,可在字符串中指定占位符

  %s 在字符串中表示任意字符
  %f 浮点数占位符
  %d 整数占位符
   b = 'hello %s' % '孙悟空'     # hello world
   b = 'hello %s,hi %s' % ('tom','Kitty')    # hello tom,hi kitty
   b = 'hello %3.5s' % 'abcdefg'   %3s字符串的长度限制在3-5之间  hello abcde
   b = 'hello %.2f' % 123.456   # hello 123.46
   b = 'hello %d' % 123.95  # 123

2.5 格式化字符串,通过在字符串前添加一个f来创建格式化字符串。在格式化字符串中可以直接嵌入变量

c = 12  
d = f'abc {c}'   # abc 12

2.6 多个参数

name =  '孙悟空'
print('欢迎',name,'光临!')  # 欢迎孙悟空光临!

2.7 字符串的复制(将字符串和数字相乘):解释器会将字符串重复指定的次数并返回

a = a * 20

2.8 空值 (None)

2.9 类型检查

type()用来检查值的类型,并将检查的结果作为返回值返回,可通过变量来接收函数的返回值

print( type(1) )            #  <class 'int'>
print( type(1.5) )      #  <class 'float'>
print( type(True) )     #  <class 'bool'>
print( type('hello') )    #  <class 'str'>
print( type(None) )     #  <class 'NoneType'>

3. 对象 object

3.1 对象的结构

- 每个对象中都要保存三种数据
    - id(标识)
        > id用来标识对象的唯一性,每一个对象都有唯一的id
        > 对象的id就相当于人的身份证号一样
        > 可以通过id()函数来查看对象的id
        > id是由解析器生成的,在CPython中,id就是对象的内存地址
        > 对象一旦创建,则它的id永远不能再改变
    - type(类型)
        > 类型用来标识当前对象所属的类型
        > 比如:int str float bool 。。。
        > 类型决定了对象有哪些功能
        > 通过type()函数来查看对象的类型
        > Python是一门强类型的语言,对象一旦创建类型便不能修改
    - value(值)
        > 值就是对象中存储的具体的数据
        > 对于有些对象值是可以改变的
        > 对象分成两大类,可变对象 不可变对象
            可变对象的值可以改变
            不可变对象的值不能改变 # int str bool None   
student={
  'name':'jack',
  'age':18,
  'height':170
  } 

3.2 类型转换

- 所谓的类型转换,将一个类型的对象转换为其他对象
- 类型转换不是改变对象本身的类型,而是根据当前对象的值创建一个新对象
类型转换的四个函数:
int() 将其他的对象转换为整型,但不会对原来的变量产生影响
  1.布尔值:True -> 1 ;  False -> 0
    2.浮点数:直接取整,省略小数点后的内容
    3.字符串:合法的整数字符串,直接转换为对应的数字;如果不是合法的整数字符串,则报错;
    4.对于其他不可转换为整型的对象(None)等,则报错;
float() 将其他的对象转换为浮点数,但不会对原来的变量产生影响
  1.布尔值:True -> 1.0 ;  False -> 0.0
    2.整数:转化成浮点数;
    3.字符串:合法的浮点数字符串,直接转换为对应的数字;如果不是合法的浮点数字符串,则报错;
    4.对于其他不可转换为整型的对象(None)等,则报错;
str() 将其他的对象转换为字符串,但不会对原来的变量产生影响;
  1.True -> 'True' ;  False -> 'False'
    2.123 -> '123'
repr() 将其他的对象转换为表达式字符串,但不会对原来的变量产生影响;
  1.对于所有表示空性的对象(0,None,'')都会转换为False,其余的转换为True

3.3 可变对象

- 每个对象中都保存了三个数据:
    id(标识)
    type(类型)
    value(值)    
- 列表就是一个可变对象
    a = [1,2,3]
- a[0] = 10 (改对象)
    - 这个操作是在通过变量去修改对象的值
    - 这种操作不会改变变量所指向的对象    
    - 当我们去修改对象时,如果有其他变量也指向了该对象,则修改也会在其他的变量中体现
- a = [4,5,6] (改变量)
    - 这个操作是在给变量重新赋值
    - 这种操作会改变变量所指向的对象
    - 为一个变量重新赋值时,不会影响其他的变量
- 一般只有在为变量赋值时才是修改变量,其余的都是修改对象
==  != 比较对象的值是否相等
is  is not 比较对象的id是否相等(更加严格)

4. 运算操作符

- 运算符可以对一个值或多个值进行运算或各种操作
- 比如 + 、-、= 都属于运算符
- 运算符的分类:
    1.算术运算符(+ - * /等)
      +:两个字符串之间进行加法运算,进行拼串操作;
        *:字符串和数字相乘,则对字符串进行复制操作,将字符串重复指定的次数;
        /:运算时结果总会返回一个浮点类型;
        //:整除,只会保留计算后的整数位,总会返回整型;
        **:幂运算,求一个值的几次幂;
        %:取模,求两个数相除的余数;
    2.赋值运算符(= += %= //= %=等)
    3.比较运算符(> >= <= == !=等):比较两个值之间的关系,返回一个布尔值
      在python中可对两个字符串进行大于(等于)或小于(等于)的运算,实际上比较的是字符串的Unicode编码,并且是逐位比较的;(如果不希望比较两个字符串的Unicode编码,则需要将其转换为数字然后再比较)
    4.逻辑运算符
      not 非  (一元)
          a = True  b = not a  print(b)  #False
            a = 1 a = not a   print(a)  #False
        and 与 (二元):只有在符号两侧的值都为True时,才会返回True,只要有一个False就返回False;
                Python中的与运算是短路的与,如果第一个值为False,则不再看第二个值
        or 或 (二元):Python中的或运算是短路的或,如果第一个值为True,则不再看第二个值
          result = True or False    print(result) #True
        非布尔值的与或运算
          当对非布尔值进行与或运算时,Python会将其当做布尔值运算,最终返回原值
            1 and 2 #2    1 or 2 #1
            1 and 0 #0    1 and 0 #1
            0 and None #0   0 and None #None
        补充:逻辑运算符可以连着使用; 1 < 2 < 3 #相当于1 < 2 and 2 < 3
    5.条件运算符(三元运算符) 
      语句1 if 条件表达式 else 语句2

5. 列表

- 列表是Python中的一个对象
- 对象(object)就是内存中专门用来存储数据的一块区域
- 之前我们学习的对象,像数值,它只能保存一个单一的数据
- 列表中可以保存多个有序的数据
- 列表是用来存储对象的对象
- 列表的使用:
    1.列表的创建
    2.操作列表中的数据
列表中存储的数据,称为元素
一个列表中可存储多个元素,也可在创建列表时,来指定列表中的元素
列表中可保存任意的对象
# myList = [10,'hello',[1,2],True,None,print]
通过索引获取列表中的元素,语法:myList[索引]
列表中的索引可以是负数,-1表示倒数第一个,-2表示倒数第二个
print(myList[-1]) # <built-in function print>
len(),该函数可获取列表的长度
print(len(myList)) # 6
切片:从现有列表中,获取一个子列表
  语法:列表[起始:结束]
        1.通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
        2.做切片操作时,总会返回一个新的列表,不影响原来的列表
        3.如果省略起始位置,则会从第一个元素开始截取
        4.如果省略结束位置,则会一直截取到最后
        5.如果起始位置和结束位置都省略,相当于创建了一个列表的副本
    语法:列表[起始:结束:步长]
      1.步长:每次获取元素的间隔,默认值是1
        2.步长不能是0,但可为负数(从列表后部向前边取元素)
          num = [1,2,3,4,5,6,5,6]
          num[1:4:2]  #[2,4]
            num[::3]  #[1,4]
            num[::-1] #[6,5,6,5,4,3,2,1]
+ 可将两个列表拼接为一个列表
* 可将列表重复指定的次数
in  用来检查指定元素是否存在于列表中,如果存在 返回True,否则返回False
  print(5 in num)   #True
not in  用来检查指定元素是否存在于列表中,如果存在 返回False,否则返回True
min() 获取列表中的最小值 print(min(num))  #1
max() 获取列表中的最大值
方法一:必须通过 对象.方法() 的形式调用
index() 获取指定元素在列表中的第一次出现时的索引,若没有该元素则报错
  index()的第二个参数,表示查找的起始位置,第三个参数,表示查找的结束位置
  num.index(2)  #1
count() 统计指定元素在列表中出现的次数
  num.count(5)  #2
修改列表
  newList = ['hi',5,10,'haha','2']
    1.通过索引修改元素
      newLsit[0] = 'hello'
    2.通过del删除元素
      del newList[2]
    3.通过切片修改列表,在给切片赋值时,只能使用序列
      newList[0:2] = [1,2,3]  print(newList) #[1,2,3,10,'haha','2']
        向索引为0的位置插入元素
        newList[0:0] = ['你好']  print(newList) #['你好','hi',5,10,'haha','2']
        当设置步长时,序列中元素的个数必须和切片中元素的个数一致
        newList[::2] = [8,8,8]  print(newList)  #[8,5,8,'haha',8]
    4.通过切片删除元素
      del newList[0:2]
        del newList[::2]
        newList[0:2] = []
方法二:
  num1 = [1,2,3,4,5]
    num2 = [-1,1,5,2,1]
    1.append()  向列表的最后添加一个元素
      num1.append(6)  #[1,2,3,4,5,6]
    2.insert()  向列表的指定位置插入一个元素
      num1.insert(2,6)  #[1,2,6,3,4,5]
    3.extend()  使用新的序列来扩展当前序列。需要一个序列作为参数,将该序列中的元素添加到当前列表中。
      num1.extend([6,7,8])  #[1,2,3,4,5,6,7,8]
    4.clear() 清空序列
      num1.clear()  #[]
    5.pop() 根据索引删除被返回被删除的元素
      num1.pop(2) #3  num1 = [1,2,4,5]
        num1.pop() 删除最后一个元素 #[1,2,3,4]
    6.remove()  删除指定值的元素,如果相同值的元素有多个,只会删除第一个,无返回值。
      num1.remove(2)  #[1,3,4,5]
    7.reverse() 反转列表
      num1.reverse()  #[5,4,3,2,1]
    8.sort()  对列表中的元素排序,默认是升序排列
      num2.sort()  #[-1,1,1,2,5]
        降序:num2.sort(reverse = True)  #[5,2,1,1,-1]
遍历列表
  num2 = [1,2,3,4,5,6,7,8]
    1.通过while循环来遍历列表
        i = 0
        while i < len(num2):
          print(num2[i])
            i += 1
    2.通过for循环来遍历列表
      语法: for 变量  in  序列:
                代码块
        for循环的代码会执行多次,序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变     量,可通过变量来获取列表中的元素。for()循环除了创建方式外,其余的都和while一样,包括else break
        continue都可在for循环中使用。
        for i in num2:
            print(i)
    3.range() 用来生成一个自然数的序列,可创建一个指定次数的for循环
      三个参数:1.起始位置(可省略,默认为0)
            2.结束位置
              3.步长(可省略,默认为1)
         for i range(20):
              print(i)

6. 序列 sequence

- 序列是Python中最基本的一种数据结构
- 数据结构指计算机中数据存储的方式
- 序列用于保存一组有序的数据,所有的数据在序列当中都有一个唯一的位置(索引)
    并且序列中的数据会按照添加的顺序来分配索引
- 序列的分类:
    可变序列(序列中的元素可以改变):
        > 列表(list)
    不可变序列(序列中的元素不能改变):
        > 字符串(str)    
        > 元组(tuple)
    通过list()函数将其他的序列转换为list
      a = 'haha'  b = list(a) #['h','a','h','a']

7. 元组 tuple

元组是不可变序列(不能尝试为元组中的元素重新赋值),它的操作方式基本上和列表一致.
1.创建元组
  当元组不是空元组时,括号可省略。
    如果元组不是空元组,它里面至少要有一个,
  myTuple = (1,2,3,4)
2.元组的解构,将元组中每一个元素都赋值给一个变量
  a,b,c,d = myTuple
    2.1 交互a和b的值
      a,b = (b,a)
    2.2 对元组进行解构时,变量的数量必须和元组中的元素的数量一致,可在变量的前面添加一个*,这个变量将会获取
      元组中所有剩余的元素。不能同时出现两个或以上的*变量。
        a,b,*c = myTuple  # a = 1 b = 2 c = [3,4]

8. 字典 dict

- 字典属于一种新的数据结构,称为映射(mapping)
- 字典的作用和列表类似,都是用来存储对象的容器
- 列表存储数据的性能很好,但是查询数据的性能的很差
- 在字典中每一个元素都有一个唯一的名字,通过这个唯一的名字可以快速的查找到指定的元素
- 在查询元素时,字典的效率是非常快的
- 在字典中可以保存多个对象,每个对象都会有一个唯一的名字
    这个唯一的名字,我们称其为键(key),通过key可以快速的查询value
    这个对象,我们称其为值(value)
    所以字典,我们也称为叫做键值对(key-value)结构
    每个字典中都可以有多个键值对,而每一个键值对我们称其为一项(item)
1.创建字典
  1.1 使用{}创建字典,语法:{key:value,key:value}
        字典的值可以是任意对象
        字典的键可以是任意的不可变对象(int str bool tuple等),但一般使用str
        字典的键是不能重复的,如果重复 后面的会替换前边的
        a = {
            'name':'孙悟空',
            'category':'猴子'
        }
  1.2 使用dict()函数创建字典
      每个参数都是一个键值对,参数名就是键,参数名就是值(这种方式创建的字典,key都是字符串)
    b = dict(name = '猪八戒',age = 20,sex = '男')
  1.3 将一个包含有双值子序列的序列转换为字典
        双值序列,序列中只有两个值,[1,2] ('a',3) 'ab'
          子序列,如果序列中的元素也是序列,称这个元素为子序列  [(1,2),('a','b')]
        c = dict([('name','沙僧'),('age',30)])
2.根据键获取值
  2.1 语法:d[key] 如果键不存在,会报错
    print(a['name'])  # 孙悟空
    2.2 get(key[,default])  用来根据键来获取字典中的值,如果获取的键在字典中不存在,则返回None。也可指     定一个默认值,作为第二个参数,这样获取不到值时 将返回默认值
      print(a.get('hello','默认值')) # 默认值
3.len() 获取字典中键值对的个数
4.in 检查字典中是否包含指定的键  print('name' in a) #True
  not in 检查字典中是否不包含指定的键
5.修改字典
  5.1 语法:a[key] = value 如果key存在则覆盖,不存在则添加
        a['name'] = '牛魔王' # 修改字典中的key-value
        a['address'] = '火焰山' #向字典中添加key-value
    5.2 setdefault(key[,default]) 用来向字典中添加key-value
        如果key已经存在于字典中,则返回key的值,不会对字典做任何操作
          如果key不存在,则向字典中添加这个key,并设置value
            result = a.setdefault('hihi','红孩儿')
    5.4 update([other]) 将其他字典中的key-value添加到当前字典中。
        如果有 重复的key,则后面的会替换掉当前的
        a.update(b)   
          print(a)  #{'name': '猪八戒', 'category': '猴子', 'age': 20, 'sex': '男'}
6.删除
  6.1 使用 del 删除字典中的 key-value
      del a['name'] a = {'category':'猴子'}
    6.2 popitem()  随机删除字典里的一个键值对,一般都会删除最后一个键值对
        删除之后,会将删除的key-value作为返回值返回,返回的是一个元组,元组中有两个元素,第一个元素是        删除的key,第二个是删除的value。
        a.popitem()
    6.3 pop(key[,default]) 根据key删除字典中的key-value,将被删除的value返回。
        如果删除不存在的key,会抛出异常。如果指定了默认值,再删除不存在的key时,不会报错,而是直接返回        默认值。
        a.pop('name')
        a.pop('hh','这是默认值')
    6.4 clear() 用来清空字典
        d.clear()
7. copy() 该方法用于对字典进行浅复制
      复制以后的对象,和原对象是独立,修改一个不会影响另一个
        注意:浅复制会简单复制对象内部的值,如果值也是一个可变对象,这个可变对象不会被复制
          a.copy()
8.遍历字典
  d = {'name':'孙悟空','age':18,'sex':'男'}
  8.1 keys() 返回字典里的所有的key。该方法会返回一个序列,序列中保存有字典的所有的键。
      通过遍历keys()获取所有键
         for k in d.keys():
            print(k,d[k])
    8.2 values() 返回一个序列,序列中保存有字典的左右的值
    8.3 items() 返回字典中所有项。
        它会返回一个序列,序列中包含有双值子序列。双值分别是:字典中的key和value
          for k,v in d.items():
                print(k,'=',v)  # name = 孙悟空  age = 18 sex = 男   

9. 集合 set

- 集合和列表非常相似
- 不同点:
    1.集合中只能存储不可变对象
    2.集合中存储的对象是无序(不是按照元素的插入顺序保存)
    3.集合中不能出现重复的元素
1.创建
  1.1 使用{}创建集合
      s = {1,2,6,4,7}
    1.2 使用 set() 函数创建集合
      创建空集合 s = set()
    1.3 通过set()将序列和字典转换为集合
      s = set([1,2,3,4,1,1,2])  # {1,2,3,4}
        s = set('hello')  # {'h','o','l','e'}
        # 使用set()将字典转化为集合时,只会包含字典中的键
        s = set({'a':1,'b':2,'c':3}) # {c,a,b}
2.使用 in 和 not in 检查集合中的元素
3.使用 len() 获取集合中元素的数量
4. add() 向集合中添加元素 s.add(10)
5. update() 将一个集合中的元素添加到当前集合中,可传递序列或字典作为参数,字典只会使用键
  s2 = set('hello')
    s.update(s2)  # {'h', 1, 2, 'o', 4, 'e', 6, 7, 'l'}
6.删除
  6.1 pop() 随机删除并返回一个集合中的元素
    6.2 remove() 删除集合中的指定元素   s.remove(2)
    6.3 clear() 清空集合
7.copy()对集合进行浅复制
8.集合运算:在对集合做运算时,不会影响原来的集合,而是返回一个运算结果
    s1 = {1,2,3,4,5}  s2 = {3,4,5,6,7,8}
  8.1 & 交集运算
      result = s1 & s2  # {3,4,5}
    8.2 | 并集运算
      result = s1 | s2  # {1,2,3,4,5,6,7,8}
    8.3 - 差集
      result = s1 - s2  # {1,2}
    8.4 ^ 异或集
      result = s1 ^ s2  # {1,2,6,7,8,9}
    8.5 <= 检查一个集合是否为另一个集合的子集
      result = s1 <= s2 #  False
        result = {1,2,3} <= {1,2,3}   # True
    8.6 < 检查一个集合是否为另一个集合的真子集
      result = {1,2,3} < {1,2,3}    # False
    8.7 >= 检查一个集合是否为另一个的超集
    8.8 > 检查一个集合是否为另一个的真超集


相关文章
|
4天前
|
存储 数据采集 人工智能
一:《Python基础语法汇总》— 变量与数据类型
【8月更文挑战第15天】本篇文章详细讲述了关于变量的命名规范,id()函数及Python的数据类型与强制转换
10 2
|
11天前
|
存储 数据挖掘 程序员
揭秘Python:掌握这些基本语法和数据类型,你将拥有编程世界的钥匙!
【8月更文挑战第8天】Python是一种高级、解释型语言,以简洁的语法和强大的功能广受好评。本文从基本语法入手,强调Python独特的缩进规则,展示清晰的代码结构。接着介绍了Python的主要数据类型,包括数值、字符串、列表、元组、集合和字典,并提供了示例代码。通过这些基础知识的学习,你将为深入探索Python及其在文本处理、数据分析等领域的应用打下坚实的基础。
26 3
|
19天前
|
索引 Python
Python中数据类型
【7月更文挑战第28天】
21 4
|
1月前
|
存储 Python 容器
Python基础语法:变量和数据类型详解(整数、浮点数、字符串、布尔值)
变量和数据类型是Python编程的基础,理解这些概念对于编写高效和正确的代码至关重要。通过本文的介绍,希望你能对Python中的变量和常用数据类型有一个清晰的认识,并能够在实际编程中灵活运用这些知识。
|
7天前
|
存储 Java 索引
Day 5/100:Python 变量与数据类型
Day 5/100:Python 变量与数据类型
14 0
|
1月前
|
Java 开发者 Python
Python中,字符串(String)是一种不可变的数据类型
Python中,字符串(String)是一种不可变的数据类型
|
1月前
|
索引 Python
python操作符或函数与数据类型不兼容
【7月更文挑战第11天】
25 1
|
1月前
|
存储 Python 容器
Python基础:变量和数据类型详解(整数、浮点数、字符串、布尔值)
变量和数据类型是Python编程的基础,理解这些概念对于编写高效和正确的代码至关重要。通过本文的介绍,希望你能对Python中的变量和常用数据类型有一个清晰的认识,并能够在实际编程中灵活运用这些知识。
|
1月前
|
存储 索引 Python
Python新手到高手:变量与数据类型详解
【7月更文挑战第9天】变量与数据类型是Python编程的基石。掌握这些基础概念,能够帮助你更好地理解和编写Python代码。随着学习的深入,你将逐渐学会如何运用这些基础知识来解决更复杂的编程问题。记住,编程是一个不断实践和探索的过程,只有不断地练习和思考,才能从新手成长为高手。
|
1月前
|
存储 人工智能 数据挖掘
Python中的7种基础数据类型,看这4500字就够了!
Python 语言以其简洁、高效和强大的功能,成为了无数开发者和编程爱好者的首选。无论是数据分析、人工智能、网络开发还是自动化脚本,Python 都能以其优雅的语法和丰富的库支持,让编程变得更加简单而有趣。 但正如建造一座大厦需要坚实的地基,掌握 Python 编程也需要从理解其基础数据类型开始。数据类型是编程语言中用于定义变量所存储数据种类的一种方式,它们是构建程序逻辑的基本构建块。在 Python 中,有一系列基础数据类型,它们是理解语言特性和进行高效编程的关键。