python基础语法（三）

1. 数值型数据结构

1.1 要点

在之前的博客也有提到，数值型数据结构在这里就不过多介绍了。在这里提及一些需要知道的知识点。

• int、float、complex、bool都是类，1\3.14\2+3j都对象（即实例）。这也符合python一切皆对象的原则。
• int: 在python3中，int就是长整型，理论上支持无限大的数字，但是受限于内存区域的大小。
• float: 由整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。浮点型往往不能精确表示一个数，比如π这样的无理数，它只能尽量靠近。

• bool：int的子类，也就是说int有的特性它也有，可以跟整型进行计算。仅有两个实例true、false，对应1和0。

  1.2 类型转换

• int(x)：返回一个整数
• float(x)：返回一个浮点数
• complex(x) complex(x,y)：返回一个复数

• bool(x)：返回一个布尔值，在前面的python基础语法（二）中的3.2.2里面已经提及，这里不再赘述。

num1 = 1234 # 一个整数
num2 = 3.14159  # 一个浮点数

print(float(num1))      # 整数转浮点数
print(int(num2))        # 浮点数转整数
print(complex(num1))    # 整数转复数
print(bool(num2))       # 整数转布尔值
---------------------------------------
1234.0
3
(1234+0j)
true

1.3 进制转换

• bin(x)：返回一个二进制数
• otc(x)：返回一个八进制数

• hex(x)：返回一个十六进制数

  注意，返回的是一个字符串，不能当做数字使用

print(bin(10))  
print(oct(10))
print(hex(20))
-------------
0b1010
0o12
0x14

1.4 数字处理相关函数

1.4.1 取整

在处理数字时，往往需要对数字进行取整或者四舍五入等操作，这时候可以用math库来对数据进行处理

import math

print(math.floor(2.5))      # math.floor()函数向下取整
print(math.ceil(2.5))       # math.ceil()函数向上取整
print(round(2.51))          # round()函数四舍六入，注意，是四舍六入
print(round(2.5))
print(round(2.4))
----------------------
2
3
3
2
2

关于round()很多同学会觉得奇怪，为什么是四舍六入，我们平时不是四舍五入的吗？这里，是因为在python3的文档中规定了小数距离哪个数更近就往哪边取整，至于0.5，就向偶数取整。有关于这个函数的说明可以查看。建议尽量避免使用这个函数，免得出问题。

1.4.2 最大值与最小值

在一组数中，我们可能需要取最大值或者最小值，使用max()函数可以取最大值，min()函数取最小值。

list = [1,3,2,9,6,4,5,0]
print(min(list))    # min()函数取最小值
print(max(list))    # max()函数取最大值
--------------------------------------
0
9

1.4.2 特殊数值

有时候我们需要定义一些特殊值进行计算，比如π、常数e等等。

import math
print(math.pi)  # math.pi返回π的近似值
print(math.e)   # math.e返回常数e的近似值
---------------------
3.141592653589793
2.718281828459045

1.5 类型判断

• type(obj)，返回obj的类型，不是字符串
• isinstance(obj, classinfo)，返回布尔值

首先介绍type()函数，它返回的是数据类型

a = 5
b = 'hello'
print(type(a))
print(type(b))
--------------
<class 'int'>
<class 'str'>

那么如何做类型判断呢？请看下面例子

a = 5
b = 'hello'
if type(a)==int:
    print(true)
if type(b)==str:
    print(true)
-----------------
true
true

isinstance(obj,classinfo)用作判断obj(对象或实例)是否等于classinfo(直接或间接类名、基本类型或者由它们组成的元组)。

>>>a = 2
>>> isinstance (a,int)
true
>>> isinstance (a,str)
false
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 true
true

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

2 列表list

• 一个队列，一个排列整齐的队伍，它是有序的。
• 列表内的个体称为元素item，由若干个元素有序地排列组成列表。
• 元素可以是任意对象（数字、字符串、对象、列表等）
• 列表内元素有顺序，可以使用索引index,索引从0开始
• 使用[]表示
• 列表是可变的
• 列表不能一开始就定义大小

• 列表是结合顺序表和链表的一种动态类型

  2.1 初始化

  定义一个新的空的列表，有两种方法yidong

list1 = []      # 这种方法更常用
list2 = list()  # 这个list()就是list类，在帮助文档中有说明

注意：在列表中不能一开始就定义列表大小，但是在其他语言中，往往建议初始化就要定义大小，这和语言的优化策略有关。

使用help()函数可以查看内置的帮助文档，这里摘取help(list)一部分，下面的魔术方法暂时忽略。

help on class list in module builtins:

class list(object)
 |  list(iterable=(), /)    
 |  
 |  built-in mutable sequence.  # 这说明了list是一种python内置的可变的队列数据结构
 |  
 |  if no argument is given, the constructor creates a new empty list.  # 如果没有接收到参数，构造器建立一个新的空列表
 |  the argument must be an iterable if specified.# 如果指定参数，它必须是一个可迭代的对象，比如range(1,5)
 |  
 |  methods defined here:
 |  
 |  __add__(self, value, /)
 |      return self+value.
 |  
 |  __contains__(self, key, /)
 |      return key in self.

这里演示指定一个可迭代对象为参数

list1=list(range(1,5))
print(list1)
--------------------
[1, 2, 3, 4]

如果给一个已经存在的列表赋值新的元素，那么它之前的元素就回收了，回收机制也就是之前提过的gc机制

2.2 索引访问

• 索引（index）也叫作下标，相当于一个目录
• 正索引：从左至右，从0开始，为列表中每一个元素编号
• 负索引：从右到左，从-1开始
• 正负索引不可以超界，否则引发异常indexerror
• 为了方便理解，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是上界，右边是下界

列表通过索引访问，list[index]index就是索引，使用中括号访问

list1 = [5,1,'h',3.2,[1,2]] #列表内的元素可以是任意对象
print("list1的第1号元素是"+list1[1])  # 利用索引查找元素
------------
list1的第1号元素是1

2.3 列表查询

• index(value, start=0, stop=len(string))
  • 通过值value，从指定区间查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配不到就抛出异常valueerror

list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.index('c')    # 查找list1中第一个'c'元素的索引值
>>> 2
list1.index('c',3)  # 查找list1中从索引值3开始找到的第一个'c'元素的下标
>>> 3
list1.index('c',3, 4) # 查找list1中从索引值3开始到索引值4结束，找到的第一个'c'元素的下标
list1.index('c',4)  # 查找list1中从索引值4开始找到的第一个'c'元素的下标
---------------------------------------------------------------------------
valueerror                                traceback (most recent call last)
<ipython-input-3-4a6e298ce585> in <module>
      2 list1.index('c')
      3 list1.index('c',3)
----> 4 list1.index('c',4)

valueerror: 'c' is not in list

• count(value)：返回列表中匹配value的次数

list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.count('c')
>>> 2

• len(list)：返回列表list长度

list1= ['a', 'b', 'c', 'c', 'd', 'e']
len(list1)
>>> 6

2.4 列表元素修改

• 索引访问修改
  • list(index) = value
  • 索引不能超界

  list1= ['a', 'b', 'c', 'c', 'd', 'e']
  list1[1]='f'
  print(list1)
  >>> ['a', 'f', 'c', 'c', 'd', 'e']

  2.5 列表增加、插入元素

• append(obj) -> none
  • 列表尾部追加元素，返回none
  • 返回none就意味着没有新的列表产生，就地修改
  • 时间复杂度是o(1)

list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.append('f')
print(list1)
>>> list1= ['a', 'b', 'c', 'c', 'd', 'e', 'f']

• insert(index, object) -> none
  • 在指定的索引index处插入元素object
  • 返回none就意味着没有新的列表产生，就地修改
  • 时间复杂度为o(n)
  • 索引超越上界，在尾部追加，超越下界，在头部追加

list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.insert(1, 'f')    # 在索引1处插入'f'元素，原来索引1处的元素的索引位置统统往后挪
print(list1)
>>> ['a', 'f', 'b', 'c', 'c', 'd', 'e']

append()和insert()都可以修改列表，但是append()比较常用，运行效率也比较快，而insert()则不太常用，一方面容易打乱原有的元素所在索引位置，另一方面运行效率不高，在列表中间插入一个元素会导致其后面的元素在内存中的位置都要挪动。

• extend(iterable) -> none
  • 将可迭代对象的元素追加进来，返回none
  • 返回none就意味着没有新的列表产生，就地修改

list1=['a', 'b', 'c']
list2=['d', 'e']
list1.extend(list2)
print(list1)
>>> ['a', 'b', 'c', 'd', 'e']

• + -> list
  • 连接操作，将两个列表连接起来
  • 产生新的列表，原列表不变
  • 本质上调用的是__add__()方法

list1=['a', 'b', 'c']
list2=['d', 'e']
list3 = list1 + list2
print(list3)
>>> ['a', 'b', 'c', 'd', 'e']

• * -> list
  • 重复操作，将本列表元素重复n次，返回新的列表

list1=['a', 'b', 'c']
list2 = list1 * 3
print(list2)
>>> ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

2.6 列表删除元素

• remove(value) -> none
  • 从左到右查找第一个匹配value的值，移除这个值
  • 就地修改
  • 效率和insert()类似
• pop(index) -> item
  • 不指定索引index，就从列表尾部弹出一个元素
  • 指定索引index，就从索引处弹出一个元素
• clear() -> none
  • 清除列表所有元素，剩下一个空列表

list1=['a', 'b', 'c', 'd', 'e']
list1.remove('a')
print(list1)
>>> ['b', 'c', 'd', 'e']
item = list1.pop()
print(list1)
>>> ['b', 'c', 'd']
print(item)
>>> e
list1.clear()   # 清空list1

clear()操作会触发gc垃圾回收机制，如果在服务器繁忙运行的时候，突然大规模内存需要gc垃圾回收，这时运行效率就会被拉低。

2.7 列表其他操作

• reverse() -> none
  • 将列表元素反转，返回none
  • 就地修改

list1=['a', 'b', 'e', 'd', 'c']
list1.reverse()
print(list1)
>>> ['c', 'd', 'e', 'b', 'a']

• sort(key=none， reverse=false) -> none
  • 对列表元素进行排序，就地修改，默认升序
  • reverse为true，反转，降序
  • key一个函数，指定key如何排序，如list.sort(key=functionname)

list1=['a', 'b', 'e', 'd', 'c']
list1.sort()
print(list1)
>>> ['a', 'b', 'c', 'd', 'e']
------------------------------------
# 获取列表的第二个元素
def takesecond(elem):
    return elem[1]
  
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takesecond)
 
# 输出类别
print ('排序列表：', random)
>>> 排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

• in
  • [3,4] in [1, 2, [3, 4]],返回布尔值，可用作判断

  • for x in [1, 2, 3, 4]

    在python基础语法(一)有提及，可以回顾一下

以上为python基础语法的第二部分，下一个部分将在下一篇博客中介绍。