len函数python用法如下：
网站建设哪家好，找成都创新互联公司！专注于网页设计、网站建设、微信开发、微信小程序定制开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了茂名免费建站欢迎大家使用！
操作设备：戴尔笔记本电脑
操作系统：win10
操作程序：python2017
1、len函数的作用就是返回容器中项目的数目。
2、len的变量必须是容器，单独的数字行不通：a=2，print(len(a))。
3、容器可以是列表：a=[]，print(len(a))。
4、容器可以是嵌套列表：a=[[],1,2,3,[1,2,3]]，print(len(a))。
5、容器可以是字符串。
6、字符串的长度与字符有关：a='abcdefg369，print(len(a))。
7、反斜杠组合而成的转移符，只是一个字符：a='\n\t'，print(len(a))，这里要特别注意，\n是一个字符。
函数原型 ：range（start， end， scan):
参数含义 ：start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;
end:技术到end结束， 但不包括end. 例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
里面的一个坑：
我的理解是for循环是针对里面的每一个在range（5）的数进行循环里面的操作。
程序的输出结果如下：
函数：len()
1：作用： 返回字符串、列表、字典、元组等长度
2：语法： len(str)
3：参数：
str：要计算的字符串、列表、字典、元组等
4：返回值 ：字符串、列表、字典、元组等元素的长度
5：实例
用len()求得数组a的长度为4，其中range（len(a)）等价于range（4）,输出结果都为[0,1,2,3]
choice()需要import random
功能：返回列表、元组、字符串的随即项
↑↑↑点击上方蓝字，回复资料，10个G的惊喜
作者：陈tooyoung@阿里云Python训练营 博客地址：
Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。
列表的定义
列表的创建
向列表中添加元素
删除列表中的元素
获取列表中的元素
列表的常用操作符
列表的其他方法
元组
创建和访问一个元组
更新和删除一个元组
元组相关的操作符
内置方法
解压元组
列表
简单数据类型
整型
浮点型
布尔型
容器数据类型
列表
元组
字典
集合
字符串
列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为[元素1, 元素2, ..., 元素n]。
关键点是「中括号 []」和「逗号 ,」
中括号 把所有元素绑在一起
逗号 将每个元素一一分开
列表的创建 创建一个普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7]
利用range()创建列表x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2]
利用推导式创建列表x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
创建一个混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]]
创建一个空列表empty = []
print(empty, type(empty)) # []
列表不像元组，列表内容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、删除 (remove,pop) 这些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
严格来说append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj)在编号index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
删除列表中的元素
list.remove(obj)移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del var1[, var2 ……]删除单个或多个对象。
如果知道要删除的元素在列表中的位置，可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0])) # Monday
print(x[-1], type(x[-1])) # ['Thursday', 'Friday']
print(x[-2], type(x[-2])) # Wednesday
切片的通用写法是start : stop : step
"start :"
以step为 1 (默认) 从编号start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
": stop"
以step为 1 (默认) 从列表头部往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
"start : stop"
以step为 1 (默认) 从编号start往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- "start : stop : step"
以具体的step从编号start往编号stop切片。注意最后把step设为 -1，相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
" : "
复制列表中的所有元素（浅拷贝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
浅拷贝与深拷贝list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
列表的常用操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
列表的其它方法
list.count(obj)统计某个元素在列表中出现的次数
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)对原列表进行排序。
key-- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse-- 排序规则，reverse = True降序，reverse = False升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
元组
「元组」定义语法为：(元素1, 元素2, ..., 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开
创建和访问一个元组
Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python')
print(t2, type(t2))
# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)
print(type(x)) #
x = 2, 3, 4, 5
print(type(x)) #
x = []
print(type(x)) #
x = ()
print(type(x)) #
x = (1,)
print(type(x)) #
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
创建二维元组。
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)
更新和删除一个元组week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元组相关的操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
内置方法
元组大小和内容都不可更改，因此只有count和index两种方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count('python')是记录在元组t中该元素出现几次，显然是 1 次
index(10.31)是找到该元素在元组t的索引，显然是 1
解压元组
解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2
元组是一种固定长度、不可变的Python对象序列。创建元组最简单的办法是用逗号分隔序列值：
tuple 函数将任意序列或迭代器转换为元组：
中括号 [] 可以获取元组的元素， Python中序列索引从0开始 ：
元组一旦创建，各个位置上的对象是无法被修改的，如果元组的一个对象是可变的，例如列表，你可以在它内部进行修改：
可以使用 + 号连接元组来生成更长的元组：
元组乘以整数，则会和列表一样，生成含有多份拷贝的元组：
将元组型的表达式赋值给变量，Python会对等号右边的值进行拆包：
拆包的一个常用场景就是遍历元组或列表组成的序列：
*rest 用于在函数调用时获取任意长度的位置参数列表：
count 用于计量某个数值在元组中出现的次数：
列表的长度可变，内容可以修改。可以使用 [] 或者 list 类型函数来定义列表：
append 方法将元素添加到列表尾部：
insert 方法可以将元素插入到指定列表位置：
（ 插入位置范围在0到列表长度之间 ）
pop 是 insert 的反操作，将特定位置的元素移除并返回：
remove 方法会定位第一个符合要求的值并移除它：
in 关键字可以检查一个值是否在列表中；
not in 表示不在：
+ 号可以连接两个列表：
extend 方法可以向该列表添加多个元素：
使用 extend 将元素添加到已经存在的列表是更好的方式，比 + 快。
sort 方法可以对列表进行排序：
key 可以传递一个用于生成排序值的函数，例如通过字符串的长度进行排序：
bisect.bisect 找到元素应当被插入的位置，返回位置信息
bisect.insort 将元素插入到已排序列表的相应位置保持序列排序
bisect 模块的函数并不会检查列表是否已经排序，因此对未排序列表使用bisect不会报错，但是可能导致不正确结果
切片符号可以对大多数序列类型选取子集，基本形式是 [start:stop]
起始位置start索引包含，结束位置stop索引不包含
切片还可以将序列赋值给变量：
start和stop可以省略，默认传入起始位置或结束位置，负索引可以从序列尾部进行索引：
步进值 step 可以在第二个冒号后面使用， 意思是每隔多少个数取一个值：
对列表或元组进行翻转时，一种很聪明的用法时向步进值传值-1：
dict(字典)可能是Python内建数据结构中最重要的，它更为常用的名字是 哈希表 或者 关联数组 。
字典是键值对集合，其中键和值都是Python对象。
{} 是创建字典的一种方式，字典中用逗号将键值对分隔：
你可以访问、插入或设置字典中的元素,:
in 检查字典是否含有一个键：
del 或 pop 方法删除值， pop 方法会在删除的同时返回被删的值，并删除键：
update 方法将两个字典合并：
update方法改变了字典元素位置，对于字典中已经存在的键，如果传给update方法的数据也含有相同的键，则它的值将会被覆盖。
字典的值可以是任何Python对象，但键必须是不可变的对象，比如标量类型（整数、浮点数、字符串）或元组（且元组内对象也必须是不可变对象）。
通过 hash 函数可以检查一个对象是否可以哈希化（即是否可以用作字典的键）：
集合是一种无序且元素唯一的容器。
set 函数或者是用字面值集与大括号，创建集合：
union 方法或 | 二元操作符获得两个集合的联合即两个集合中不同元素的并集：
intersection 方法或 操作符获得交集即两个集合中同时包含的元素：
常用的集合方法列表：
和字典类似，集合的元素必须是不可变的。如果想要包含列表型的元素，必须先转换为元组：
