【Python基础】2. 基本数据类型

2. 基本数据类型

---

2.1 数字类型

2.1.1 数字类型的组成

1. 整数——不同进制的转换

   • 默认输入十进制

   • 二进制0b，八进制0o，十六进制0x

   • 十进制与其他进制的转换

     a = bin(16) # 转二进制
     b = oct(16) # 转八进制
     c = hex(16) # 转十六进制
     print(a, b, c) # 0b10000 0o20 0x10
     

     注意：上述转换后的结果为字符串类型

   • 其他进制转十进制

     d = int(a, 2) #二进制转十进制
     e = int(b, 8) # 八进制转十进制
     f = int(c, 16) # 十六进制转十进制
     print(d, e, f) # 16 16 16
     

2. 浮点数——不确定性

   不确定小数问题

   print(0.1 + 0.2) # 0.30000000000000004
   

   计算机采用二进制的小数部分来表示浮点数的小数部分

   • 部分小数不能用二进制小数完全表示

     

   • 通常情况下不会影响计算精度

   • 四舍五入获得精确解

     a = 3 * 0.1
     print(a) # 0.30000000000000004
     b = round(a, 1)
     print(b) # 0.3
     print(b == 0.3) # True
     

3. 复数——a + bj

   • 大写 J 或者 小写 j 均可
   • 虚部系数为1时，需要显式写出

2.1.2 数字运算操作符（a 操作符 b）

1. 加减乘除运算：+, -. *, /

2. 取反： -

   x = 1
   print(-x)
   

3. 乘方运算：**

   2 ** 3
   

4. 整数商// 和 模运算%

   13 // 5 # 整数商，x/y 向下取整
   13 % 5 # ，模运算，余数 13 = 2*5 + 3
   

几点说明：

• 整数与浮点数的运算结果是浮点数
• 除法运算的结果是浮点数

2.1.3 数字运算操作函数

1. 求绝对值 abs()

   abs(-5)
   

2. 幂次方 pow(x, n)

   pow(2, 5) # 2^5
   print(pow(2, 5, 3)) # 2^5 % 3
   

3. 四舍五入 round(x, n)

   a = 21.4326
   print(round(a)) # 默认四舍五入为整数
   print(round(a, 2)) # 参数2表示四舍五入后保留2位小数
   print(round(a, 5)) # 位数不足，无需补齐
   

4. 整数商和模运算 divmod(x, y)

   等价于返回二元元组（x // y, x % y）

   print(divmod(13, 5)) # (2, 3)
   

5. 序列最大/ 最小值 max(), min()

   a = [1, 34, 5, 7,898, 745, 23]
   print(max(a))
   print(min(a))
   

6. 求和 sum(x)

   print(sum([1, 2, 3, 4, 5]))
   

7. 借助科学计算库 math / scipy / numpy

   import math
   print(math.exp(1)) # 指数运算 e^1
   print(math.log2(2)) # 对数运算
   print(math.sqrt(4)) # 开平方运算
   
   import numpy as np
   a = [1, 2, 3, 4, 5]
   print(np.mean(a)) # 求均值
   print(np.median(a)) # 求中位数
   print(np.std(a)) # 求标准差
   

---

2.2 字符串类型

2.2.1 字符串的表达

• 用 “” 或 ‘’ 括起来的任意字符

• 字符串中有双引号或单引号的情况

  • 双中有单

  • 单中有双

  • 双中有双、单中有单——转义符 \

    print("\"python"\ is good")
    

  • 转义符可以用来换行继续输入

2.2.2 字符串的性质

1. 字符串的索引

   s = "My name is Paper Pig"
   
   # 正向索引，从0开始
   print(s[0])
   print(s[3])
   print(s[4])
   
   # 反向索引，从-1开始
   print(s[-1])
   print(s[-2])
   

2. 字符串的切片

   变量名[开始位置：结束位置：切片间隔]

   • 切片间隔如不设置默认为1，可省略
   • 切片范围不包含结束位置
   • 起始位置是0时，可以省略
   • 结束位置省略，代表可以取到最后一个字符
   • 可以使用反向索引号

   var = "python"
   print(var[0: -1: 2]) # pto
   

   • 反向切片

     • 起始位置时-1也可以省略
     • 结束位置省略，代表可以取到第一个字符

     var = "python"
     print(var[:: -1]) # nohtyp
     

2.2.3 字符串操作符

1. 字符串的拼接

   字符串1+字符串2

2. 字符串的成倍复制

   字符串 * n n * 字符串

   var = "python"
   print(var * 3) # pythonpythonpython
   print(3 * var) # pythonpythonpython
   

3. 成员运算

   • 子集 in 全集：任何一个连续的切片都是原字符串的子集

     address = "Peter, John and Mike"
     print("Peter" in address) # True
     

   • 遍历字符串字符

     for s in "address":
         print(s)
     

2.2.4 字符串处理函数

1. 字符串的长度

   s = "python"
   print(len(s))
   

2. 字符编码

   • 将中文字库、英文字母、数字、特殊字符等转换成计算机可识别的二进制数

     • 每个单一字符对应一个唯一的互不重复的二进制编码
     • Python中使用的是Unicode编码

   • 将字符转换为Unicode编码——ord(字符)

     print(ord('l')) # 108
     

   • 将Unicode编码转换为字符——chr(Unicode编码)

     print(chr(108)) # l
     

2.2.5 字符串的处理方法

1. 字符串的分割——split

   • 返回一个列表
   • 原字符串不变

   languages = "Java, C, C++, Python"
   print(languages.split(",")) # ['Java', ' C', ' C++', ' Python']
   

2. 字符串的聚合——“聚合字符”.join(可迭代数据类型)

   • 可迭代类型，如：字符串、列表

     s = "12345"
     s_join = ",".join(s)
     print(s_join) # 1,2,3,4,5
     

   • 序列类型的元素必须是字符类型

     s = ["1", "2", "3", "4", "5"]
     print("*".join(s)) # 1*2*3*4*5
     

3. 删除两端特定字符——字符串.strip(删除字符)

   • strip从两侧开始搜索，遇到指定字符执行删除，遇到非指定字符，搜索停止
   • 类似的还有做删除lstrip和右删除rstrip

   s = "             I have many blanks         "
   print(s.strip(" ")) # I have many blanks
   print(s.lstrip(" ")) # I have many blanks         
   print(s.rstrip(" ")) #              I have many blanks
   

4. 字符串的替换——字符串.replace(“被替换”, “替换成”)

   s = "Python is coming"
   s1 = s.replace("Python", "Py")
   print(s1) # Py is coming
   print(s) # Python is coming
   

5. 字符串统计——字符串.count(“待统计字符串”)

   s = "xasdgwuqyfgasxasasasasasasasfxxxxxxxc"
   print(s.count("x")) # 9
   print(s.count("sa")) # 6
   

6. 字符串字母大小写

   s = "pYtHon"
   print(s.upper()) # PYTHON 字母全部大写
   print(s.lower()) # python 字母全部小写
   print(s.title()) # Python 首字母大写
   

---

2.3 布尔类型

2.3.1 逻辑运算的结果

a = 10
print(a > 8) # True
print(a == 10) # True
print(a < 10) # False

• any(), all()

  print(any([False, 1, 0, None])) # 只要有非0 就为True
  print(all([False, 1, 0, None])) # 全都是非0，才能True
  

2.3.2 指示条件

n = 2800
while True:
    m = eval(input("请输入一个正整数"))
    if m == n:
        print("猜对了")
        break
    elif m > n:
        print("太大了")
    else:
        print("太小了")

2.3.3 作为掩码

import numpy as np
x = np.array([1, 2, 4, 3, 6, 5]) #定义numpy数组
print(x > 3) # [False False  True False  True  True]
print(x[x > 3]) # [4 6 5]

---

2.4 类型判别及类型转换

2.4.1 类型判别

• type(变量)

  age = 20
  name = "Mike"
  print(type(age)) # <class 'int'>
  print(type(name)) # <class 'str'>
  

• isinstance(变量, 预判类型)：承认继承

• 变量类型是预判类型的子类型，则为真，否则为假

  age = 20
  name = "Mike"
  
  print(isinstance(age, int)) # True
  print(isinstance(age, object)) # True
  print(isinstance(name, object)) # True
  

• 字符串检查方法

  • 字符串.isdigit() 字符串是否只有数字组成

    age = "20"
    name = "324khdfoas"
    print(age.isdigit()) # True
    print(name.isdigit()) # False
    

  • 字符串.isalpha()字符串是否只有字母组成

    age = "20"
    name = "324khdfoas"
    txt = "dfsjihgg"
    print(name.isalpha()) # False
    print(txt.isalpha()) # True
    

  • 字符串.isalnum()字符串是否只有数字和字母组成

    age = "20"
    name = "324khdfoas"
    txt = "dfsjihgg"
    address = "dashdiu1344&&&"
    
    print(name.isalnum()) # True
    print(txt.isalnum()) # True
    print(age.isalnum()) # True
    print(address.isalnum()) # False
    

2.4.2 类型转换

• 数字类型转字符串——str(数字类型)

  age = 20
  print("My age is " + str(age))
  

• 仅有数字组成的字符串转数字——int()，float()，evail()

  s1 = "20"
  s2 = "213.4"
  
  print(int(s1)) # 20
  print(float(s2)) # 213.4
  print(float(s1)) # 20.0
  
  print(eval(s1)) # 20
  print(eval(s2)) # 213.4