1.全局函数

type()
和print搭配，输出变量的数据类型。
str()
将数字类型，列表类型，元组类型转换为字符串类型。

del( value )

不是方法的用法，而是函数的用法，直接使用 del( str ) 的方式删除元素，可以指定删除的元素 del( a[0] )，适用于字符串，列表，元组(只能全部删除)，字典，集合

2.字符串的方法

find()
查找字符串中输入字符第一次出现的位置的下标。

  1. a = 'abcde'
  2. print(a.find('b'))  # 输出1

lower()

将字符串中的大写转换为小写

upper()

将字符串中的小写转换为大写

split() （十分常用，在做数据处理时，在获取get方法提交的属性时常用）

按照输入的字符切割字符串，返回值是一个列表

  1. a = 'abc,eee'
  2. print(a.split(','))  # 输出结果：['abc','eee']

strip()

删除字符串头尾指定的字符（默认为空格），在js中使用trip()不过只删除头部的空格

切片操作 变量名[startIndex : endIndex+1 : step]

可以对字符串或者列表进行切割，从开始索引直到结尾的位置（但不包括结尾），即包前不包尾
step可以设置切割时的步长，可以跳步截取，默认为1，设置为2则是每取一个跳过一个。

  1. b = 'abcdef'
  2. # 字符串和列表类型可以倒序取值
  3. print(b[-2]) # 输出e
  4. # 切片操作，也适用于列表
  5. c = b[1:5:2]  # 输出bd
  6. print(c)

3.列表类型[]

切片操作 变量名[startIndex : endIndex+1 : step]

可以对字符串或者列表进行切割，从开始索引直到结尾的位置（但不包括结尾），即包前不包尾
step可以设置切割时的步长，可以跳步截取，设置为1则每取一个跳过一个。

append()

往列表的末尾插入参数。

extend( [ ] )

extend()需要传入一个列表，效果将两个列表合并。

insert()

往指定的列表下标位置插入元素。

pop( value )

默认删除列表的最后一个元素，并且会返那个被删除的数。

remove( value )

删除列表中指定的参数，没有返回值。

全局函数 ： del( value )

不是方法的用法，而是函数的用法，直接使用 del( str ) 的方式删除列表中的所有元素，亦可以指定删除那个元素 del( a[0] )

4.元组类型

元组类型以小括号表示 a=(1,2,3)
元组是在初始化后就固定了，不许增减，只能一次删除整个元组。
元组和列表一样都是序列的存储容器，存储元素的地址，不过不同的是元组无法改变，并且python中会有隐式创建元组的情况：

  1. a = () # 元组类型
  3. a = (1) # int类型，因为除了1以外没有别的元素了。
  4. a = (1,) # 元组类型，加逗号就会隐式创建元组类型
  5. a = ('Hello') # str类型，与第二个例子同理。

del()函数

删除整个元组

元组类型的定义与小括号无关，只有变量后接逗号，才会被判断为是元组，元组的类型是tuple，也有一个tuple()函数，来讲其他类型转换为元组类型

5.字典类型

字典类型类似Java中的HashMap和JavaScript的对象，以键值对的方式存放数据。

  1. # 字典
  2. d = {'key':'value','name':'ricky'}
  3. print(type(d),d)
  4. print(d['name'])

字典的取值通过中括号加键名获得，字典变量[ 键名 ]。这就与JS不同了
关于字典中的键：
键必须是可哈希的

大多数Python对象可以作为键，但它们必须是可哈希的对象。像列表和字典这样的可变类型，由于它们不是可哈希的，所以不能作为键。 所有不可变的类型都是可哈希的，因此它们都可以做为字典的键。要说明的是：值相等的数字表示相同的键，即整型数字1和浮点数1.0的哈希值是相同的，它们是相同的键。

同时，也有一些可变对象(很少)是可哈希的，它们可以做字典的键，但很少见。举一个例子，一个实现了hash() 特殊方法的类。因为hash()方法返回一个整数，所以仍然是用不可变的值(做字典的键)。 为什么键必须是可哈希的？解释器调用哈希函数，根据字典中键的值来计算存储你的数据的位置。如果键是可变对象，它的值可改变。如果键发生变化，哈希函数会映射到不同的地址来存储数据。如果这样的情况发生，哈希函数就不可能可靠地存储或获取相关的数据。选择可哈希的键的原因就是因为它们的值不能改变。

例如d = {(‘a’,’b’):(3,7)}

上述例子，就是把元组当作字典的键，可以看到没有报错，说明元组充当字典的键也是可以的。

数字和字符串可以被用做字典的键，元组是不可变的但也可能不是一成不变的，因此用元组做有效的键必须要加限制：若元组中只包括像数字和字符串这样的不可变参数，才可以作为字典中有效的键。

6.关于del()函数删除的对象

https://www.cnblogs.com/xisheng/p/7340514.html

1.首先介绍下python的对象引用

1）Python中不存在传值调用，一切传递的都是对象引用，也可以认为是传址调用。即Python不允许程序员选择采用传值或传引用。Python参数传递采用的是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。如果函数参数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过”传值”来传递对象。

2）当复制列表或字典时，就复制了对象列表的引用，如果改变引用的值，则修改了原始的参数。

3）为了简化内存管理，Python通过引用计数机制实现自动垃圾回收功能，Python中的每个对象都有一个引用计数，用来计数该对象在不同场所分别被引用了多少次。每当引用一次Python对象，相应的引用计数就增1，每当消毁一次Python对象，则相应的引用就减1，只有当引用计数为零时，才真正从内存中删除Python对象。

2. 可变对象与不可变对象的概念与分类

Python在heap中分配的对象分成2类：
不可变对象（immutable object）：Number（int、float、bool、complex）、String、Tuple. 采用等效于“传引用”的方式。

可变对象（mutable object）：List、dictionary.采用等效于“传值”的方式。

3. del 是删除引用而不是删除对象，对象由自动垃圾回收机制（GC）删除

看这个例子：

  1. >>> x = 1
  2. >>> del x
  3. >>> x
  4. Traceback (most recent call last):
  5.   File "<pyshell#28>", line 1, in <module>
  6.     x
  7. NameError: name 'x' is not defined
  8. >>> x = ['Hello','world']
  9. >>> y = x
  10. >>> y
  11. ['Hello', 'world']
  12. >>> x
  13. ['Hello', 'world']
  14. >>> del x
  15. >>> x 
  16. Traceback (most recent call last):
  17. File "<pyshell#32>", line 1, in <module>
  18. x
  19. NameError: name 'x' is not defined
  20. >>> y
  21. ['Hello', 'world']
  22. >>>

可以看到x和y指向同一个列表，但是删除x后，y并没有受到影响。这是为什么呢？
The reason for this is that you only delete the name,not the list itself,In fact ,there is no way to delete values in python(and you don’t really need to because the python interpreter does it by itself whenever you don’t use the value anymore)
举个例子，一个数据（比如例子中的列表），就是一个盒子，我们把它赋给一个变量x，就是好像把一个标签x贴到了盒子上，然后又贴上了y，用它们来代表这个数据，但是用del删除这个变量x就像是把标有x的标签给撕了，剩下了y的标签。
再看一个例子：

  1. shoplist = ['apple', 'mango', 'carrot', 'banana']
  2. print ('The first item I will buy is', shoplist[0])
  3. olditem = shoplist[0]
  4. del shoplist[0]  #del的是引用，而不是对象
  5. print ('I bought the',olditem)
  6. print ('My shopping list is now', shoplist)
  7. print(shoplist[0])
  8. 结果为：
  9. The first item I will buy is apple
  10. I bought the apple
  11. My shopping list is now ['mango', 'carrot', 'banana']
  12. mango

实例补充：

  1. #!/usr/bin/evn python
  2. # -*- coding:utf-8 -*-
  3. # Author: antcolonies
  4. '''
  5. python中的内置方法del不同于C语言中的free和C++中的delete
  6.   （free和delete直接回收内存，当然存储于该内存的对象也就挂了）
  7. Python都是引用，垃圾回收为GC机制
  8. '''
  10. '''
  11. if __name__ == '__main__':
  12.     a = 1          # 对象 1 被 变量a引用，对象1的引用计数器为1
  13.     b = a          # 对象1 被变量b引用，对象1的引用计数器加1
  14.     c = a          # 对象1 被变量c引用，对象1的引用计数器加1
  15.     del a          # 删除变量a，解除a对1的引用，对象1的引用计数器减1
  16.     del b          # 删除变量b，解除b对1的引用，对象1的引用计数器减1
  17.     print(c)       # 1
  18. '''
  20. if __name__=='__main__':
  21.     li=['one','two','three','four','five']  # 列表本身不包含数据'one','two','three','four','five'，而是包含变量：li[0] li[1] li[2] li[3] li[4]
  22.     first=li[0]       # 拷贝列表，也不会有数据对象的复制，而是创建新的变量引用
  23.     del li[0]
  24.     print(li)         # ['two','three','four','five']
  25.     print(first)      # one
  26.     list1 = li
  27.     del li
  28.     print(list1)      # ['two', 'three', 'four', 'five']
  29. #   print(type(li))   # NameError: name 'li' is not defined