Python基础笔记(二)

1. List和Tuple

List和Tuple是Python的内置的数据类型，区别在于可变和不可变，List用[]表示，Tuple用()表示，它们之间可以相互转换：

Copy
# List to Tuple
myList = [1, 2, 3, 4]
myTuple = tuple(myList)

# Tuple to List
myTuple = ("A", "B", "C")
myList = list(myTuple)

可以使用len()函数计算长度：

Copy
myList = [1, 2, 3, 4]
myTuple = ("A", "B", "C")
print(len(myList))
print(len(myTuple))
# 4 3

由于Tuple是用小括号来声明，当只有一个元素时，为了避免歧义，需要加入一个逗号：

Copy
myTuple = (100)
print(myTuple)
# 100

myTuple = (100,)
print(myTuple)
# (100,)

Python通过索引获取列表内单一元素，并且支持索引值为负数，即从数组的末尾开始计数：

Copy
myList = [1, 2, 3, 4, 5]
print(myList[1])
# 2
print(myList[-1])
# 5

从上面的例子可以看出，索引值为正数时从索引0开始，索引值为负数时从索引-1开始，索引-1代表最后一个元素myList[len(myList)-1]。
下面是List的常用增删改操作：
(1) 添加

Copy
myList = [1, 2, 3, "A", "B", "C"]

myList.append(4)
# 向列表末尾添加'4'
# [1, 2, 3, 'A', 'B', 'C', 4]

myList.extend(["X", "Y", "Z"])
# 向列表末尾添加新列表
# [1, 2, 3, 'A', 'B', 'C', 4, 'X', 'Y', 'Z']

myList.insert(2, "apple")
# 在索引2处插入'apple'
# [1, 2, 'apple', 3, 'A', 'B', 'C', 4, 'X', 'Y', 'Z']

(2) 删除

Copy
myList = [1, 2, 3, "A", "B", "C"]

delItem = myList.pop()
# 删除列表末尾元素，将返回被删除的元素
# [1, 2, 3, 'A', 'B'], delItem = 'C'

delItem = myList.pop(1)
# 删除索引1处的元素
# [1, 3, 'A', 'B'], delItem = 2

del myList[2]
# 删除索引2处的元素
# [1, 3, 'B']

del myList[0:2]
# 删除索引0到索引2(不包括索引2)的所有元素
# ['B']

myList.remove('B')
# 删除元素'B'
# []

(3) 获取

Copy
myList = [1, 2, 3, 4, "A", "B", "C", "X", "Y", "Z"]

print(myList[3])
# '4'

newList = myList[:3]
# 从索引0开始，取到索引3(不包括索引3)
# [1, 2, 3]

newList = myList[4:]
# 从索引4开始，取到最后一个元素
# ['A', 'B', 'C', 'X', 'Y', 'Z']

newList = myList[4:6]
# 从索引4开始，取到索引6(不包括索引6)，[m:n]可以理解为从m开始，取n-m个元素
# ['A', 'B']

newList = myList[-3:-1]
# 从索引-3开始，取到索引-1(不包括索引-1)
# ['X', 'Y']

newList =  myList[:-5]
# 从索引0开始，取到索引-5(不包括索引-5)
# [1, 2, 3, 4, 'A']

newList = myList[1:8:4]
# 从索引1开始，取到索引8(不包括索引8)，每2个元素取1个
# [2, 4, 'B', 'X']

newList = myList[:]
# 原样复制一个List，等效于newList = myList
# [1, 2, 3, 4, 'A', 'B', 'C', 'X', 'Y', 'Z']

newList = myList[::-1]
# 将当前List倒序输出，得到一个新List(不影响原List)
# ['Z', 'Y', 'X', 'C', 'B', 'A', 4, 3, 2, 1]

myStr = "ABCDEFGHIJKL"[3:6]
# 字符串也是一个List，从第3个字符取到第6个字符(不包括第6个字符)
# 'DEF'

myStr = "ABCDEFGHIJKL"[::2]
# 整个字符串每2个字符取1个字符，生成新字符串
# 'ACEGIK'

for k, v in enumerate(myList):
    print(k, v)
# 遍历myList，同时列出数据和数据下标
# 0 1
# ...
# 9 Z

myList = [1, 2, 3, 4, 5]
newList = [i*i for i in myList]
# 将List里的每个元素取平方，得到新List
# [1, 4, 9, 16, 25]

对纯数字的列表，可以通过min(),max(),sum()来进行科学计算

Copy
myList = [1, 2, 3, 4, 5]

minItem = min(myList)
# 1

maxItem = max(myList)
# 5

sumResult = sum(myList)
# 15

(4) 判断

Copy
myList = ["A", 1, 2, 3, "A", "B", "C", "X", "Y", "Z", "A"]
myStr = "What can I do for you?"

result = "what" in myStr.lower()
result = "WHAT" in myStr.upper()
# 判断"what"是否在字符串内出现过，返回True或False；
# Python是大小写敏感的，可以全部转换成大写或小写来比较，此处返回True

result = "X" not in myList
# 判断"X"是否不在当前列表，此处返回False

result = myList.count("A")
# 判断元素"A"在列表里出现的次数，此处得到3

result = myStr.count("a")
# 判断字符"a"在字符串里出现的次数，此处得到2

index = myList.index("A")
# 获取元素"A"在列表里的索引，此处得到0

index = myList.index("A",3)
# 在列表索引3(包括索引3)开始获取元素"A"在列表里的索引，此处得到4

try:
    index = myList.index("A",5,100)
except ValueError:
    print("该元素不在List内")
else:
    print(index)
# 当index的参数在列表或字符串并不存在，会抛异常，这里需要捕获异常再处理，此处得到10

(5) 排序

Copy
myList1 = [8, 2, 100, 23]
myList2 = ["W", "A", "X", "T"]

myList1.reverse()
# 反转列表
# [23, 100, 2, 8]

myList1.sort()
# 按升序排列
# [2, 8, 23, 100]

myList2.sort()
# 按升序排列
# ['A', 'T', 'W', 'X']

myList1.sort(reverse=True)
# 按倒序排列
# [100, 23, 8, 2]

2. 数组

Python也有array模块，array中的类型必须全部相同，并且在声明时就要明确指定元素的类型，只支持一维数组：

Copy
import array

myArray = array.array('i', [1, 3, 5])

print(myArray)
# array('i', [1, 3, 5])

print(myArray[1])
# 3

另一个更好的选择是NumPy库的数组，它是Python数组的一个扩展，Python3.4以后的版本可以使用以下命令安装NumPy库：

Copy
pip3 install numpy

(1) 创建

Copy
import numpy as np

myArray = np.array([44, 88, 22, "ABC"])
# 直接按指定元素创建数组，当同时存在数字和字符串，会把数字当做字符串处理
# ['44' '88' '22' 'ABC']

myArray = np.arange(1, 10, 2, dtype=np.int16)
# 以1为起点，10为终点(不包括10)，间隔为2，数据类型为Int16方式创建数组
# [1 3 5 7 9]

myArray = np.ones((2,3), dtype=np.int16, order="C")
# # 创建一个2*3的二维数组，数组的每个元素都为"1"，数据类型是Int16，存储方式按C语言的按行存储
# [[1 1 1]
#  [1 1 1]]

myArray = np.zeros(8, dtype=np.float, order="F")
# 创建一个长度为8的一维数组，数组元素都为"0"，数据类型是Float，存储方式按Fortran语言的按列存储
# [0. 0. 0. 0. 0. 0. 0. 0.]

myArray = np.empty(8, np.str, order="C")
# 创建一个长度为8的一维字符串数组，数组的每个元素都为空
# ['' '' '' '' '' '' '' '']

myArray = np.linspace(20, 100, 50, endpoint=False, retstep=False)
# 在20-100之间，取50个点
# endpoint：如果为True，则一定包括stop；如果为False，一定不包括stop
# retstep：如果为True，则返回数组和步长；如果为False，只返回数组

myRandInt = np.random.randint(5)
# 在0-5之间取一个随机数，数组中可能有"0"，但不会有"5"

myArray = np.random.randint(1,100,10)
# 在1-100之间生成包含10个随机数的数组，数组中可能有"1"，但不会有"100"
# [41 58 55  1 94 58 36 17 84 47]

myArray = np.random.randint(1,100,(2,3))
# 在1-100之间取随机数生成一个2*3的数组
# [[89 86  7]
#  [67 39 58]]

(2) 添加
NumPy的数组不能动态改变大小，numpy.append()函数会新建数组，不会影响原数组。

Copy
import numpy as np

myArray1 = np.array([1, 2, 3, 4, 5])
myArray2 = np.array(["A", "B", "C"])
myList1 = [6, 7, 8]
myList2 = ["X", "Y", "Z"]

print(np.append(myArray1, myArray2))
# 将myArray1和myArray2合并为一个新数组
# ['1' '2' '3' '4' '5' 'A' 'B' 'C']

newArray = np.array([], dtype=np.int16)
for i in myList1:
    newArray = np.append(newArray, i)
print(newArray)
# 循环访问myList1，将每个元素添加到newArray末尾
# [6 7 8]

print(np.append(myArray1, 9))
# 在myArray1末尾单独添加一个数字9
# [1 2 3 4 5 9]

print(np.append(myArray2, myList2))
# 将myList2添加到myArray2末尾
# ['A' 'B' 'C' 'X' 'Y' 'Z']

print(np.concatenate((myArray1, myList1, myArray2),axis=0))
# 将两个数组，一个列表拼接起来
# ['1' '2' '3' '4' '5' '6' '7' '8' 'A' 'B' 'C']

myArray1 = np.array([[1, 2, 3], [4, 5, 6]])
myArray2 = np.array([["A", "B", "C"],["X", "Y", "Z"]])
myArray3 = np.array([["一", "二", "三"],["四", "五", "六"]])

newArray1 = np.concatenate((myArray1, myArray2, myArray3), axis=0)
print(newArray1)
# 按顺序添加三个数组的所有元素，axis=0可以省略，axis对于一维数组无效
# [['1' '2' '3']
#  ['4' '5' '6']
#  ['A' 'B' 'C']
#  ['X' 'Y' 'Z']
#  ['一' '二' '三']
#  ['四' '五' '六']]

newArray2 = np.concatenate((myArray1, myArray2, myArray3), axis=1)
print(newArray2)
# 依次添加三个数组的索引0的元素，然后添加索引1的元素(直到添加到最大索引处的元素)
# [['1' '2' '3' 'A' 'B' 'C' '一' '二' '三']
#  ['4' '5' '6' 'X' 'Y' 'Z' '四' '五' '六']]

其它操作大致与List相同，可参考List的示例。

3. 字典

Copy
myDict = {"name":"wayne", "age":25, "skills":["java", "python", "ruby"]}

myDict["name"] = "tom"
# 新增一个元素，如果key已存在，则修改对应的value

# if not myDict.get("nickname"):
if not "nickname" in myDict:
    myDict["nickname"] = "mario"
# 如果字典里没有"nickname"这个key，则用指定值添加

print(myDict.keys())
# 输出所有key
# dict_keys(['name', 'age', 'skills'])

print(myDict.values())
# 输出所有value
# dict_values(['tom', 25, ['java', 'python', 'ruby']])

print(myDict.items())
# 输出所有items
# dict_items([('name', 'tom'), ('age', 25), ('skills', ['java', 'python', 'ruby'])])

for k in myDict:
    v = myDict.get(k)
    print(k,":",v)
# 遍历整个字典
# name : tom
# age : 25
# skills : ['java', 'python', 'ruby']

newDict = myDict.copy()
# 拷贝字典
# {'name': 'tom', 'age': 25, 'skills': ['java', 'python', 'ruby']}

myDict.pop("age")
# 移除key为"age"的元素
# {'name': 'tom', 'skills': ['java', 'python', 'ruby']}

myDict.popitem()
# 移除最后一个元素
# {'name': 'tom'}

myDict.clear()
# 清空字典
# {}

4. 集合

集合(set)里的元素是无序的，它最大的特点是没有重复元素，如果尝试添加重复元素则会被自动过滤。

Copy
mySet = set([1, 1, "A", "A", 3, 3])
print(mySet)
# {1, 'A', 3}

mySet1 = set([1, 2, 3])
mySet2 = set([2, 3, 4])

# 取交集
mySet = mySet1 & mySet2
print(mySet)
# {2, 3}

# 取并集
mySet = mySet1 | mySet2
print(mySet)
# {1, 2, 3, 4}