python元组

元组

python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，列表使用方括号，元组声明后，长度就固定了。

In [1]: my_strs=("a","bbb",'ccc')

In [2]: my_strs
Out[2]: ('a', 'bbb', 'ccc')

In [3]: my_strs[0]
Out[3]: 'a'

In [4]: my_strs[-1]
Out[4]: 'ccc'

In [5]: my_strs[3]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-5-978c5894f0f0> in <module>()
----> 1 my_strs[3]

IndexError: tuple index out of range

In [6]: my_strs[0]="aaa"
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-4152d9453e33> in <module>()
----> 1 my_strs[0]="aaa"

TypeError: 'tuple' object does not support item assignment

In [8]: len(my_strs)  #定义好了元组，长度就固定了。
Out[8]: 3


In [11]: name=[1,2,3,4]

In [12]: my_tuple=(100,200,name) #元组中的元素为列表

In [13]: my_tuple
Out[13]: (100, 200, [1, 2, 3, 4])

In [15]: my_tuple[2]
Out[15]: [1, 2, 3, 4]

In [16]: my_tuple[2][0]=100 #元组中若包含列表，列表本身是可以修改的。

In [17]: my_tuple
Out[17]: (100, 200, [100, 2, 3, 4])

元组没有增删改，只有查操作内置函数index， count ，in， not in

In [17]: my_tuple
Out[17]: (100, 200, [100, 2, 3, 4])

In [19]: my_tuple.index(100)
Out[19]: 0

In [20]: my_tuple.count(100)
Out[20]: 1

In [21]: 100 in my_tuple
Out[21]: True

In [22]: 100 not in my_tuple
Out[22]: False

In [23]:

实现列表循环输出

#用for循环实现
In [23]: for i in name:
    ...:     print(i)
    ...:     
100
2
3
4

In [24]: for i in my_tuple:
    ...:     print(i)
    ...:     
    ...:     
100
200
[100, 2, 3, 4]

In [25]: range(1,100)
Out[25]: range(1, 100)

In [26]: for i in range(1,10):
    ...:     print(i)
    ...:     
1
2
3
4
5
6
7
8
9

In [27]: c=range(1,10)

In [28]: c
Out[28]: range(1, 10)

#用while实现
In [29]: i=0

In [30]: while i<len(name):
    ...:     print(name[i])
    ...:     i+=1
    ...:     
100
2
3
4

range的优化：

[root@localhost ~]# python
Python 2.6.6 (r266:84292, Aug 18 2016, 15:13:37) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> c=range(1,10) 
>>> c
[1, 2, 3, 4, 5, 6, 7, 8, 9] #python2中直接返回列表
>>> exit()
[root@localhost ~]# python3
Python 3.6.5 (default, May  1 2018, 16:43:30) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-18)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> c=range(1,10)     #懒加载，只有使用访问里面的元素时才会得到一个列表，节省内存空间。 python3优化后的处理。
>>> c
range(1, 10)

可变类型和不可变类型（值是可变还是不可变）

不可变类型：数值、字符串、元组...

可变类型：列表、字典

说明：

python中的整数不限制大小，数值占用的字节1、2、4、8...由于整数占用的字节大小是不同的，因此不能更改。

字符串定义好之后不会改变，字符串的操作是生成新的字符串，原本的字符串没有改变。

In [31]: a=1 #变量a指向数值为1的内存空间；

In [32]: a
Out[32]: 1

In [33]: a=2 #变量a指向数值为2的内存空间

In [34]: a  #改变的是a的引用指向，并非将原本1的内存的值修改为2，当内存中的值没有被任何一个变量引用的时候，内存会自动回收
Out[34]: 2

字符串不可变类型举例

In [1]: a="abc"

In [2]: a.replace("a","A")
Out[2]: 'Abc'   #函数的返回值。并没有对原字符串进行修改，原有变量的指向并没有改变，返回的值在内存的另一块区域中，且没有变量指向它。

In [3]: a
Out[3]: 'abc'

In [4]: b=a.replace("a","A") #函数返回的值赋值给b，那么b就指向这个返回值。

In [5]: b
Out[5]: 'Abc'

In [6]: a
Out[6]: 'abc'

In [12]: a=[1,2] #内存区域中存在了一个列表，变量a指向此列表。

In [13]: b=a #把a指向的内存地址赋值给b，b也指向此列表，a和b指向同一个内存地址

In [14]: a
Out[14]: [1, 2]

In [15]: b
Out[15]: [1, 2]

In [16]: id(a)  #id()给出变量的内存地址
Out[16]: 139815303764104

In [17]: id(b)
Out[17]: 139815303764104 #a和b的地址相同

In [18]: b+=[3,4] #右边列表加列表，列表为可变类型，会发生变化。

In [19]: b  #指向内存空间的列表发生变化
Out[19]: [1, 2, 3, 4]

In [20]: a #由于a也指向此内存空间，因此a的值也会发生变化
Out[20]: [1, 2, 3, 4]

In [23]: a=[1,2]

In [24]: b=a

In [25]: b=b+[3,4]  #等号的右边是表达式，先执行表达式，得到新的列表，再赋值给b，则左边变量b指向一个全新的列表，而a的指向没有改变，因此值还是没有改变。因此b=b+x  b+=x 在可变类型中内存的指向是不一样的。

In [26]: b
Out[26]: [1, 2, 3, 4]

In [27]: a
Out[27]: [1, 2]

公共方法：

运算符

+ 合并字符串、列表、元组

* 复制字符串、列表、元组

in 元素是否存在字符串、列表、元组、字典

not in 元素是否不存在字符串、列表、元组、字典

内置函数

cmp(item1，item2):比较两个值大小，返回值为-1、0、1，python2中支持，python3不支持

>>> a=1
>>> b=2
>>> c=cmp(a,b) 
>>> c
-1
>>> c=cmp(b,a)
>>> c
1
>>> c=cmp(a,a)
>>> c
0

>>> a="e"
>>> b="f"
>>> cmp(a,b)
-1
>>> cmp(b,a)
1
>>> cmp(a,a)
0

len(item)：计算容器中的元素个数

max(item)：返回容器中元素最大值

min(item)：返回容器中元素最小值

del(item)：删除容器

In [35]: a=[44,33]

In [36]: max(a)
Out[36]: 44

In [37]: min(a)
Out[37]: 33

In [38]: len(a)
Out[38]: 2

In [39]: del a

多维列表、元组的访问

In [40]: tuple=([2,3],[4,5])

In [41]: tuple[0]
Out[41]: [2, 3]

In [42]: tuple[0][0]
Out[42]: 2

In [43]: tuple[0][-1]
Out[43]: 3

练习：统计给定一个字符串，其中字符出现的次数。

  1 #字符串中字符出现的个数
  2 str=input("请输入一个字符串")
  3 res={}#字典中的key不可能重复
  4 for i in str:
  5     if i in res:#表示字符i在字符串中已经出现过，把原来的统计值加1
  6         res[i]=res[i]+1
  7     else:#表示字符在整个字符串中第一次出现
  8         res[i]=1
  9 print(res)
[root@localhost python]# python3 23.py 
请输入一个字符串hello
{'h': 1, 'e': 1, 'l': 2, 'o': 1}
[root@localhost python]#