python 基本知识总结2

Python可变和不可变类型

不可变类型	可变类型
数字类型（int、float、complex、bool) 字符串str 元组tuple	列表list 字典dict

python语句a = 1定义了一个int变量，计算机首先在内存中分配一块空间存放值1，然后将a指向1，通过a是不能改变此内存空间中保存的值的。例如重新赋值a = ‘python’ 则在内存空间新保存了值’python’，并没有改变原来内存空间保存的值1.所以称int是不可变类型。

列表是可变类型，指的是通过列表变量可以改变原内存空间的值。比如a = [1,2,3]在内存空间建立了值[1,2,3],通过a.append(4)在列表尾部追加了值4，此时原内存空间保存了值[1,2,3,4](当然需要更多地内存空间来保存值），重要的是a依旧指向的是原来的内存空间地址。

理解了可变类型和不可变类型的区别，也就能明白为什么字符串和元组没有列表的方法insert等改变内存值的方法。字符串和元组的很多方法都没有改变内存变量的值。而列表的很多方法可以改变内存值

注意
1.不可变类型不可以使用索引赋值
2.不可变类型不能使用del关键字删除元素

//查看变量的内存地址id()函数
>>> a = 1
>>> id(a)
140217749383872

//不可变类型的赋值
>>> a = 3
>>> id(a)
140217749383936

//可变类型的赋值
>>> a = [1,2,3]
>>> id(a)
140217619515656
>>> a.append(4)
>>> id(a)
140217619515656

Python字符串

python的字符串用**’ ‘** 或**” “** 创建。因为字符串是不可变类型，索引赋值、del关键字不被允许使用。通过切片实现字符串的增删改实际上是创建了新的字符串。

//创建字符串变量
>>> a = 'python'
>>> a
'python'

//字符串索引查看
>>> a[0]
'p'

//字符串索引赋值不被允许
>>> a[0] = 'h'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

//字符串del删除元素不被允许
>>> del a[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object doesn't support item deletion

//字符串拼接
>>> b = 'learn'
>>> a+b
'pythonlearn'

//字符串拼接实际上申请了新的空间保存值
>>> a
'python'
>>> b = 'learn'
>>> id(a)
140217750641664
>>> id(b)
140217750107784
>>> c=a+b
>>> id(c)
140217750104944

//切片实现字符串插入，申请新的内存空间
>>> a[:2]+'o'+a[2:]
'pyothon'
>>> d = a[:2]+'o'+a[2:]
>>> id(d)
140217750107840
>>> id(a)
140217750641664

//切片实现字符串删除
>>> a[:2]+a[3:]
'pyhon'

注意
python切片是python的重要手段，在很多包比如numpy、pandas都有继承。

字符串常用方法：len、count、index

//统计字符串长度
>>> a = 'python'
>>> len(a)
6

//统计某个字符或字符串出现的次数
>>> a.count('p')
1
>>> a.count('py')
1
>>> a.count('pl')
0

//判断子字符串出现的索引位置
>>> a.index('py')
0
>>> a.index('')
0
>>> a.index('pl')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

python元组

创建元组需要使用一对小括号，注意（1）表示int，而（1,)表示元组。元组是不可变类型，不能使用索引赋值、del的方式改变元素值。通过切片实现元组的增删改实际上是创建了新的元组。

//创建元组
>>> a = (1,2,3)
>>> type(a)
<class 'tuple'>

//(1)与（1,)的区别
>>> a=(1)
>>> type(a)
<class 'int'>
>>> a = (1,)
>>> type(a)
<class 'tuple'>

//索引查看
>>> a = (1,2,3)
>>> a[0]
1

//索引赋值和del删除不被允许
>>>a[0]=0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

//+实现元组连接(申请新的内存空间）
>>> a = (1,2,3)
>>> (0,)+a
(0, 1, 2, 3)
>>> c = (0,)+a
>>> id(a)
140217582901216
>>> id(c)
140217619503448

//切片和连接实现增加元素（创建了新的内存空间保存值）
>>> a
(1, 2, 3)
>>> a[0:1]+(0,)+a[1:]
(1, 0, 2, 3)

//切片和连接实现删除元素
>>> a
(1, 2, 3)
>>> a[0:1]+a[2:]
(1, 3)

python列表

列表的初始化采用中括号[],嵌套中括号可以表示二维数组，列表是python最常用的数据类型，相当于c++的vector.列表最常用的方法：在列表尾部增加元素append方法（可以把列表看做一个类，它包含很多方法）。
列表是可变数据类型，所以可以使用索引赋值和del删除操作，同时列表的切片实现增删改也是申请新的空间。

//创建列表
>>> a = [1,2,3]
>>> a
[1, 2, 3]

//python二维数组
>>> b = [[1,2,3],[4,5,6],[7,8,9]]
>>> b
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> b[1][1]
5

//列表尾部增加元素
>>> a.append(4)
>>> a
[1, 2, 3, 4]

//列表连接（申请新的空间）
>>> c = [5,6,7]
>>> a + c
[1, 2, 3, 4, 5, 6, 7]

>>> a = [1,2,3]
>>> c = [5,6,7]
>>> b = a+c
>>> id(a)
140217619515400
>>> id(b)
140217619516360

//在列表任意位置增加元素
>>> a = [1,2,3]
>>> a.insert(0,0)
>>> a
[0, 1, 2, 3]

//切片的方式实现元素插入以及多个元素插入
>>> [-1] +a[0:]
[-1, 0, 1, 2, 3]

//del实现元素删除（并未改变内存地址）
>>> a
[0, 1, 2, 3]
>>> id(a)
140217619515784
>>> del a[0]
>>> id(a)
140217619515784
>>> a
[1, 2, 3]

//切片实现元素删除（申请新的内存空间）
>>> a
[1, 2, 3]
>>> a[0:1]+a[2:]
[1, 3]
>>> b=a[0:1]+a[2:]
>>> id(a)
140217619515400
>>> id(b)
140217750072264

//索引[]实现查看和改变元素
>>> a
[1, 2, 3]
>>> a[0]
1
>>> a[0] = 4
>>> a
[4, 2, 3]

列表常用方法：append、insert、len、index、count、clear

>>> a = [1,2,3]
>>> len(a)
3
>>> a.index(1)
0
>>> a.count(1)
1
>>> a.clear()
>>> a
[]

重点
列表的排序可以使用方法sort
sorted是python内置的函数，它和列表自带的方法sort的区别就是：sorted不会修改原列表的值

//升序
>>> a = [1,3,2,6,9,4,5]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 6, 9]

//降序
>>> a = [1,3,2,6,9,4,5]
>>> a.sort(reverse=True)
>>> a
[9, 6, 5, 4, 3, 2, 1]

//升序，sorted
>>> a = [1,3,2,6,9,4,5]
>>> sorted(a)
[1, 2, 3, 4, 5, 6, 9]
>>> a
[1, 3, 2, 6, 9, 4, 5]

//降序，sorted
>>> a = [1,3,2,6,9,4,5]
>>> sorted(a,reverse = True)
[9, 6, 5, 4, 3, 2, 1]
>>> a
[1, 3, 2, 6, 9, 4, 5]

Python字典

创建字典使用大括号{}，键值对之间使用冒号:分隔。注意字典的键只能是不可变类型。注意字典中的键值对是无序的，所以无法使用切片。

//创建字典
>>> a = {1:"hu",2:"rong",3:"ping"}
>>> a
{1: 'hu', 2: 'rong', 3: 'ping'}

//根据键索引字典的值
>>> a[1]
'hu'

//索引改变键的值
>>> a[1] = "kang"
>>> a
{1: 'kang', 2: 'rong', 3: 'ping'}

//增加新的键值对
>>> a[0] = "xiu"
>>> a
{0: 'xiu', 1: 'kang', 2: 'rong', 3: 'ping'}

//使用del删除键值对
>>> del a[0]
>>> a
{1: 'kang', 2: 'rong', 3: 'ping'}

//实现两个字典的连接不能使用+操作符，而应该使用方法update
>>> a = {1:"hu"}
>>> b = {2:"rong"}
>>> a+b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
>>> a.update(b)
>>> a
{1: 'hu', 2: 'rong'}

字典常用操作len、count、clear、

python序列变量的公共处理方法

这里的序列变量主要是指字符串、列表、元组、字典类型变量。数据结构的基本使用包括增删改查，下面介绍增删改查的公共方法

1. 序列的增删改可以使用切片方法实现，但字典除外。它们都申请了新的空间保存修改之后的变量。
2. 通过Python的内置函数len可以查看序列的长度，其它内置函数常用的由max、min等，应用于字典时，max、min是对键的大小进行比较。
3. 使用关键字del 可以删除可变类型（列表、字典）的元素。
4. 使用**运算符+*可以实现序列的连接（字典除外），这是通过申请新的空间实现的。运算符可以实现序列的多次重复（字典除外）
5. 使用for in实现循环迭代。字典的遍历有所不同，需要注意。

>>> for a in 'python':
...     print(a)
... 
p
y
t
h
o
n

>>> for a in ('p','y','t','h','o','n'):
...     print(a)
... 
p
y
t
h
o
n

>>> for a in ['p','y','t','h','o','n']:
...     print(a)
... 
p
y
t
h
o
n

//字典的遍历顺序并非字典的定义顺序
//通过键遍历
>>> b={3:'p',2:'y',1:'t',4:'h',5:'o',6:'n'}
>>> for a in b:
...     print(b[a])
... 
t
y
p
h
o
n

>>> for a in b.keys():
...     print(b[a])
... 
t
y
p
h
o
n

//通过值遍历
>>> for a in b.values():
...     print(a)
... 
t
y
p
h
o
n

//通过键值对遍历
>>> for a,c in b.items():
...     print('key:',a,' value:',c)
... 
key: 1  value: t
key: 2  value: y
key: 3  value: p
key: 4  value: h
key: 5  value: o
key: 6  value: n