Python基本数据类型

---

title: Python基本数据类型
date: 2020-03-23 10:07:38
tags: [python,基本语法]
categories: python数据分析基础

---

本问介绍了一些python的基本数据类型，包括数值、字符串、布尔类型，着重介绍了基本数据类型的基本操作及注意事项，基本数据类型是进行数据分析的基础。

数值 Number

整数 int

1. 整数的默认输入是十进制数值

2. 数值的其他进制表示：

   二进制->0b

   八进制->0o

   十六进制->0x

• 进制表示

  print('进制表示（16 == 0b10000 == 0o20 == 0x10）：', 16 == 0b10000 == 0o20 == 0x10)
  

  输出：

  进制表示（16 == 0b10000 == 0o20 == 0x10）： True
  

进制转换 Conversion of number systems

• 十进制与其他进制转换

  1. bin(number) -> 十进制转为二进制
  2. oct(number) -> 十进制转为八进制
  3. hex(number) -> 十进制转为十六进制

  a = bin(16)
  b = oct(16)
  c = hex(16)
  print('十进制(16)转其他进制：二进制 -> {}, 八进制 -> {}, 十六进制 -> {}'.format(a, b, c))
  

  输出：

  十进制(16)转其他进制：二进制 -> 0b10000, 八进制 -> 0o20, 十六进制 -> 0x10
  

• 其他进制转换为十进制

  int(number, system) -> 其他进制转换为十进制

  参数解释：

  1. number：要转换的数值
  2. system：要转换的进制数

  a_ = int(a, 2)
  b_ = int(b, 8)
  c_ = int(c, 16)
  print('二进制({})转十进制 -> {}, 八进制({})转十进制 -> {}, 十六进制({})转十进制 -> {},'.format(a, b, c, a_, b_, c_))
  

  输出：

  二进制(0b10000)转十进制 -> 0o20, 八进制(0x10)转十进制 -> 16, 十六进制(16)转十进制 -> 16,
  

• 进制转换后返回的结果

  1. 十进制转换为其他进制结果为字符串类型
  2. 其他进制转换为十进制结果类型为整型

  print('十进制转换其他进制后结果的类型: {}'.format(type(a)))
  print('其他进制转换十进制后结果的类型: {}'.format(type(a_)))
  

  输出：

  十进制转换其他进制后结果的类型: <class 'str'>
  其他进制转换十进制后结果的类型: <class 'int'>
  

浮点数 Float

同其他编程语言一样，浮点数具有不确定性：

因为浮点数在计算机中的存储都遵循$ieee$浮点数标准,都将浮点数转换为二进制，而有些小数在转换为二进制后可能存在无限小数或者数值位数过大，而编程语言中的数值在计算机中的存储都具有严格的位数限制，因此必须做一些取舍，这样就造成了编程语言中浮点数的精度问题，也就是浮点数的不确定性。

• 浮点数的不确定性

  print('小数的不确定性，精度丢失，例如 0.1+0.2= {}'.format(0.1+0.2))
  

  输出：（计算结果应该为0.3）

  小数的不确定性，精度丢失，例如 0.1+0.2= 0.30000000000000004
  

• round(number, digit)方法获得精确解

  round(number, digit)通过四舍五入获得精确解，因为精度丢失后与原数值偏差很小，所以通过四舍五入后得到的结果就可以认为是精确解

  参数解释：

  1. number：原数据
  2. digit：保留的小数位数

  a = 3 * 0.1
  b = round(a, 1)  # 参数解释：第一个参数为原数据，第二个参数为保留的小数位数
  print('原数值: {} ，四舍五入后： {}'.format(a,b))
  

  输出：

  原数值: 0.30000000000000004 ，四舍五入后： 0.3
  

复数 Complex

$a+bj,j$不区分大小写

虚部为时，应显式的指出

• 虚数的表示

  a = 3 + 4j
  b = 5 + 1J
  print('虚数 -> {} {} {} {}'.format(a, b, type(a), type(b)))
  

  输出：

  虚数 -> (3+4j) (5+1j) <class 'complex'> <class 'complex'>
  

• 获取实部与虚部

  1. real->获得实部
  2. imag->获得虚部

  print('虚数{}的实部{}虚部{}'.format(a, a.real, a.imag))
  

  输出：

  虚数(3+4j)的实部3.0虚部4.0
  

• 共轭复数

  conjugate()获得共轭复数

  print('虚数{}的共轭复数{}'.format(a, a.conjugate()))
  

  输出：

  虚数(3+4j)的共轭复数(3-4j)
  

数值运算操作符 Numeric operator

四则基本运算

• 先乘除后加减，有括号先算括号
• 二元运算符两边留空格

print('四则基本运算 (2 + 5 - 3 * 8) / 5 = ',(2 + 5 - 3 * 8) / 5)

输出：

四则基本运算 (2 + 5 - 3 * 8) / 5 =  -3.4

乘方运算

print('2的3次方 -> {}, 2的5次方 -> {}'.format(2**3, 2**5))

输出：

2的3次方 -> 8, 2的5次方 -> 32

整数商与取模运算

• 整数商$//$，取结果的整数部分

  print('20 // 6 = ', 20 // 6)
  

  输出：

  20 // 6 =  3
  

• 取模 % ，取结果的小数部分

  print('20 % 6 = ', 20 % 6)
  

  输出：

  20 % 6 =  2
  

print('20 // 6 * 6 + 20 % 6 = ', 20 // 6 * 6 + 20 % 6)

输出：

20 // 6 * 6 + 20 % 6 =  20

特殊运算结果

• 除法的结果是浮点数

  print('10 / 5 = {}, type = {}'.format(10 / 5, type(10 / 5)))
  

  输出：

  10 / 5 = 2.0, type = <class 'float'>
  

• 整数与浮点数运算结果为浮点数

  print('2.5 * 10 = {}, type = {}'.format(2.5 * 10, type(2.5 * 10)))
  

  输出：

  2.5 * 10 = 25.0, type = <class 'float'>
  

数值运算函数 Numerical operation function

求绝对值 abs(n)

• 直接返回n的绝对值

  print('-5 的绝对值为：', abs(-5))
  

  输出：

  -5 的绝对值为： 5
  

• 返回复数的模长

  print('绝对值函数也可以求复数的模长，3+4j的模长：',abs(3+4j))
  

  输出：

  绝对值函数也可以求复数的模长，3+4j的模长： 5.0
  

幂次方 pow(x, n)

• 参数解释：

  1. x -> 原数据
  2. n -> 几次方

• 幂次方

  print('2的3次方：',pow(2,3))            # pow(x,n) <==> x**n
  

  输出：

  2的3次方： 8
  

• 幂次方后取余

  print('2^5 % 3 = ',pow(2, 5, 3))
  

  输出：

  2^5 % 3 =  2
  

四舍五入 round(x, n)

• 参数解释：

  1. x -> 元数据
  2. n -> 保留的小数位数

• 默认四舍五入到整数

  a = 2.342
  print('默认四舍五入到整数：', round(a))
  

  输出：

  默认四舍五入到整数： 2
  

• 保留两位小数

  print('保留两位小数：', round(a, 2))
  

  输出：

  保留两位小数： 2.34
  

• 小数位数不够不进行补零操作

  print('小数位数不够不进行补零操作：', round(a,6))
  

  输出：

  小数位数不够不进行补零操作： 2.342
  

整数商和求模运算 divmod(a, b)

• 参数解释：
  1. a -> 被除数
  2. b -> 除数
• 返回一个由整除结果和取模结果组成的元组
• 运算速度要比先整除后取模要快，只执行一次除法运算

print('divmod(13,5) -> {}, (13 // 5, 13 % 5) -> {}'.format(divmod(13, 5), (13 // 5, 13 % 5)))     # divmod要快，只执行一次除法运算
print(type(divmod(13, 5)))

输出：

divmod(13,5) -> (2, 3), (13 // 5, 13 % 5) -> (2, 3)
<class 'tuple'>

序列的最值

print('[3, 4, 5, 1, 34, 77, 23]的最大值：{}，最小值：{}'.format(max(a), min(a)))   # 也可以max(3, 4, 5, 1, 34, 77, 23)

输出：

[3, 4, 5, 1, 34, 77, 23]的最大值：77，最小值：1

**以max()函数为例详细解释：
max(arg1, arg2, arg3, args[, key])
max(iterable, [, key, default])

• 参数解释：

  1. key：确定取最值的方法
  2. default：当参数为空时，默认返回值

• 传入多个元素

  print(max(1, 3, 5, 3, 8, 0))
  

  输出：

  8
  

• 传入可迭代元素

  print(max('18234'))
  print(max('asffwasdz'))
  

  输出：

  8
  z
  

• 参数default的使用

  print(max((), default=0))
  

  输出：

  0
  

• 参数key的使用

  当我们传入为字典，或一个个的对象时，我们定义求最值的方法

  1. 传入字典

     print(max([{'name': 'tom', 'age': 12}, {'name': 'timi', 'age': 21}, {'name': 'mary', 'age': 31}], key=lambda x: x['age']))
     

     输出：

     {'name': 'mary', 'age': 31}
     

  2. 传入对象

     class people:
         def __init__(self, name, age):
             self.name = name
             self.age = age
     
         def __str__(self):
             return '姓名：{}  年龄：{}'.format(self.name, self.age)
     
     tom = people('tom', 12)
     timi = people('timi', 21)
     mary = people('mary', 31)
     print(max(tom, timi, mary, key=lambda x: x.age))
     

     输出：

     姓名：mary  年龄：31
     

序列求和 sum(iterable)

注：参数必须是可迭代对象

print('[3, 4, 5, 1, 34, 77, 23]求和：', sum(a))  # 不可以sum(3, 4, 5, 1, 34, 77, 23)

输出：

[3, 4, 5, 1, 34, 77, 23]求和： 147

科学计算库 math/scipy/numpy

这里只做简单介绍，无论是数据挖掘还是机器学习，数据处理都是很重要的一部分，而python提供了大量的第三方库来帮助我们处理数据，我个人推荐环境配置为Anaconda的环境，这样我们就不用自己手动pip大量的科学计算库

math

import math
print('e的1次方：',math.exp(1))
print('以2为底2的对数：', math.log2(2))
print('根号4：', math.sqrt(4))

输出：

e的1次方： 2.718281828459045
以2为底2的对数： 1.0
根号4： 2.0

numpy

import numpy as np             # numpy多用于矩阵运算
a = [1, 2, 3, 4, 5]
print('{}的平均值：{}'.format(a, np.mean(a)))
print('{}的中位数：{}'.format(a, np.median(a)))
print('{}的标准差：{}'.format(a, np.std(a)))

输出：

[1, 2, 3, 4, 5]的平均值：3.0
[1, 2, 3, 4, 5]的中位数：3.0
[1, 2, 3, 4, 5]的标准差：1.4142135623730951

博客地址