python基础系列二:列表

#-----------------------------------------创建列表------------------------------------------
# 定义
# 直接定义
nums = [1,2,3,4,5]

# 通过range函数构造,python2 和python3 版本之间的差异;
# python3 用的时候才会去构造
nums = range(1,101)

# 列表嵌套
# 注意和C语言中数组的区别,是否可以存放不同的数据类型
nums = [1,2,"ab","1",True,["a","b","c"]]

# 列表赋值给另外一个列表
# 原始的方式
nums = [1,2,3,4,5]
resultList = []
for num in nums:
resultList.append(num ** 2)
print(resultList) # [1, 4, 9, 16, 25]

#使用list()方法创建列表
list_1 = list([1,2,3])
print list_1

# 列表推导式
nums = [1,2,3,4,5]
# [表达式 for 变量 in 列表]
resultList = [num ** 2 for num in nums]
print(resultList) # [1, 4, 9, 16, 25]

# [表达式 for 变量 in 列表 if 条件]
resultList = [num ** 2 for num in nums if num % 2 != 0]
print(resultList) # [1, 9, 25]

#-------------------------------------------------------------列表的增,删,改,插------------------------------------------------------------------

#-------------------------------------增------------------------------------#
# append
# 作用
# 往列表中, 追加一个新的元素
# 在列表的最后
# 语法
# l.append(object)
# 参数
# object
# 想要添加的元素
# 返回值
# None
# 注意
# 会直接修改原数组
nums = [1, 2, 3, 4]
nums.append(5) # 无返回值 none
print(nums) # [1, 2, 3, 4, 5]

# insert
# 作用
# 往列表中, 追加一个新的元素
# 在指定索引前面
# 语法
# l.insert(index, object)
# 参数
# index
# 索引, 到时会插入到这个索引之前
# object
# 想要添加的元素
# 返回值
# None
# 注意
# 会直接修改原数组
nums = [1, 2, 3, 4]
nums.insert(2, 5)
print(nums) # [1, 2, 5, 3, 4]
# extend
# 作用
# 往列表中, 扩展另外一个可迭代序列
# 语法
# l.extend(iterable)
# 参数
# iterable
# 可迭代集合
# 字符串
# 列表
# 元组
# ...
# 返回值
# None
# 注意
# 会直接修改原数组
# 和append之间的区别
# extend可以算是两个集合的拼接

# append是把一个元素, 追加到一个集合中
nums = [1, 2, 3, 4]
nums2 = ["a", "b", "c"]
nums.extend(nums2)
print(nums) # [1, 2, 3, 4, ‘a‘, ‘b‘, ‘c‘]

# 乘法运算
# ["a"] * 3
# =
# [‘a‘, ‘a‘, ‘a‘]
nums = [1, 2]
print(nums * 2) # [1, 2, 1, 2]

# 加法运算
# ["a"] + ["b", "c"]
# =
# ["a", "b", "c"]
# 和extend区别
# 只能列表类型和列表类型相加

n1 = [1, 2]
n2 = ["a", "b"]
n3 = ["abc", "cdf"]
print(n1 + n2); #[1, 2, ‘a‘, ‘b‘]
print(n1 + n3); #[1, 2, ‘abc‘, ‘cdf‘]

# ------------------------------------------删------------------------------#
# del 语句
# 作用
# 可以删除一个指定元素(对象)
# 语法
# del 指定元素
# 注意
# 可以删除整个列表
# 删除一个变量
# 也可以删除某个元素
nums = [1, 2, 3, 4]
del nums[1]
print(nums) # [1, 3, 4]

del nums[:] #删除列表中全部元素,即清空了列表
nums = [] #可以清空列表,但不能作为函数参数执行

# pop
# 作用
# 移除并返回列表中指定索引对应元素
# 语法
# l.pop(index=-1)
# 参数
# index
# 需要被删除返回的元素索引
# 默认是-1
# 也就对应着列表最后一个元素
# 返回值
# 被删除的元素
# 注意
# 会直接修改原数组
# 注意索引越界
nums = [1, 2, 3, 4]
nums.pop() #默认-1,并返回删除的元素
nums.pop(0) #删除指定位置的元素,并返回删除的元素

print(nums)

# remove
# 作用
# 移除列表中指定元素
# 语法
# l.remove(object)
# 参数
# object
# 需要被删除的元素
# 返回值
# None
# 注意
# 会直接修改原数组
# 如果元素不存在
# 会报错
# 若果存在多个元素
# 则只会删除最左边一个
# 注意循环内删除列表元素带来的坑

nums = [1, 2, 2, 3, 4]
nums.remove(2) #则只会删除最左边一个
print(nums) #[1, 2, 3, 4]

# ---------------------------------------------改----------------------------------------#
# names[index] = 666

nums = [1, 2, 3]
nums[1] = 5
print(nums) #[1, 5, 3]

#--------------------------------------------- 查----------------------------------------#
# 获取单个元素
# items[index]
# 注意负索引
nums = [1, 2, 3]
print(nums[-1]) # 3

# 获取元素索引
# index()
nums = [1, 2, 5, 3, 4]
print(nums.index(5)) # 2

# 获取指定元素个数
# count()
nums = [1, 2, 5, 2, 3, 4]
print(nums.count(2) ) #2

# 获取多个元素
# 切片
# items[start:end:step]
# 遍历
# 方式1
# 根据元素进行遍历
# for item in list:
# print(item)
# 方式2
# 根据索引进行遍历
# for index in range(len(list)):
# print(index, list[index])
# 方式3(了解)
# 创建对应的枚举对象
# 概念
# 通过枚举函数, 生成的一个新的对象
# 作用
# 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
# 同时列出数据下标和数据
# 语法
# enumerate(sequence, [start=0])
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
#
#如果对一个列表,既要遍历索引又要遍历元素时,首先可以这样写:
list1 = ["这", "是", "一个", "测试"]
for i in range (len(list1)):
print i ,list1[i]

#上述方法有些累赘,利用enumerate()会更加直接和优美:
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
print index, item
>>>
0 这
1 是
2 一个
3 测试

#?enumerate还可以接收第二个参数,用于指定索引起始值
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
print index, item
>>>
1 这
2 是
3 一个
4 测试

# l = ["a", "b", "c"]
# enumerate(l, 1)
# 一个待枚举的对象
# 转换成为list之后, 具体数据如下
# [(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]
# 遍历枚举对象
# for index, value in 枚举对象:
# print(index, value)
# 方式4(了解)
# 使用迭代器进行遍历
# iterL = iter(list)
# for item in iterL:
# print(item)

# 访问集合的方式-迭代器
# 概念
# 迭代
# 是访问集合元素的一种方式
# 按照某种顺序逐个访问集合中的每一项
# 可迭代对象
# 能够被迭代的对象, 称为可迭代对象
# 判定依据
# 能作用于for in
# 判定方法
# import collections
# isinstance(obj, collections.Iterable)
# 迭代器
# 是可以记录遍历位置的对象
# 从第一个元素开始, 往后通过next()函数, 进行遍历
# 只能往后, 不能往前
# 判定依据
# 能作用于next()函数
# 判定方法
# import collections
# isinstance(obj, collections.Iterator)
# 注意
# 迭代器也是可迭代对象, 所以也可以作用于for in
# 为什么会产生迭代器?
# 1. 仅仅在迭代到某个元素时才处理该元素
# 在此之前, 元素可以不存在
# 在此之后, 元素可以被销毁
# 特别适合用于遍历一些巨大的或是无限的集合
# 例如 "菲波那切数列"
# 2. 提供了一个统一的访问集合的接口
# 可以把所有的可迭代对象, 转换成迭代器进行使用
# iter(Iterable)
# iter(str)
# iter(list)
# iter(tuple)
# iter(dict)
# ...
# 迭代器简单使用
# 使用next()函数, 从迭代器中取出下一个对象, 从第1个元素开始
# 因为迭代器比较常用, 所以在Python中, 可以直接作用于for in
# 内部会自动调用迭代器对象的next()
# 会自动处理迭代完毕的错误
# 注意事项
# 如果取出完毕,再继续取, 则会报错
# StopIteration
# 迭代器一般不能多次迭代

import collections

nums = [1, 2, 3]
result = isinstance(nums, collections.Iterable)
print(result) # True
result = isinstance(nums, collections.Iterator)
print(result) # Flase

# 转为迭代器
it = iter(nums)

for v in it:
print(v)

# 判定
# 元素 in 列表
# 元素 not in 列表

# 比较
# cmp()
# 内建函数
# 如果比较的是列表, 则针对每个元素, 从左到右逐一比较
# 左 > 右
# 1
# 左 == 右
# 0
# 左 < 右
# -1
# Python3.x不支持
# 比较运算符
# ==
# >
# <
# ...
# 针对每个元素, 从左到右逐一比较

# 排序
# 方式1
# 内建函数
# 可以对所有可迭代对象进行排序
# 语法
# sorted(itrearble, key=None, reverse=False)
# 参数
# itrearble
# 可迭代对象
# key
# 排序关键字
# 值为一个函数,此函数只有一个参数且返回一个值用来进行比较
# reverse
# 控制升序降序
# 默认False
# 升序
# 返回值
# 一个已经排好序的列表
# 列表类型
s = "cdefga"
result = sorted(s);
print(result) #[‘a‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘]

s = [2,3,1,4,5]
result = sorted(s, reverse = True)
print(result) #[5, 4, 3, 2, 1]

s = [("a", 16), ("a1",13), ("a2", 14)]
result = sorted(s)
print(result) #[(‘a‘, 16), (‘a1‘, 13), (‘a2‘, 14)]

#按元组的第一个元素来排序
def getKey(x):
return x[1]
result = sorted(s, key=getKey)
print(result) #[(‘a1‘, 13), (‘a2‘, 14), (‘a‘, 16)]

# 方式2
# 列表对象方法
# 语法
# list.sort(key=None, reverse=False)
# 参数
# key
# 排序关键字
# 值为一个函数,此函数只有一个参数且返回一个值用来进行比较
# reverse
# 控制升序降序
# 默认False
# 升序

s = [2,3,1,4,5]
res = s.sort()
print(res, s) # None [1, 2, 3, 4, 5] 注意和内建函数的方法不同点;

# 乱序
# 可以随机打乱一个列表
# 导入random模块
# import random
# random.shuffle(list)

import random
list = [1, 2, 3, 4, 5]
res = random.shuffle(list)
print(res, list) #None [4, 3, 5, 2, 1] 后面序列随机,修改原序列的本身

# 反转
# l.reverse()
list = [1, 2, 3, 4, 5]
res = list.reverse()
print(res, list) #None [5, 4, 3, 2, 1]

# 切片反转
# l[::-1]
list = [1, 2, 3, 4, 5]
res = list[::-1]
print(res, list) #[5, 4, 3, 2, 1] [1, 2, 3, 4, 5]

#list去重

list_1 = [‘s‘,‘a‘,‘d‘,‘s‘,‘a‘,‘d‘]
list_2 = []

for i in list_1:
if i not in list_2:
list_2.append(i)
print list_2

原文地址:https://www.cnblogs.com/lisonglin/p/10248063.html

时间: 2024-10-29 19:02:50

python基础系列二:列表的相关文章

Python基础(二)

Python基础(二) Python 运算符(算术运算.比较运算.赋值运算.逻辑运算.成员运算) 基本数据类型(数字.布尔值.字符串.列表.元组.字典.set集合) for 循环 enumrate range和xrange 编码与进制转换 Python 运算符 1.算术运算: 2.比较运算: 3.赋值运算: 4.逻辑运算:  5.成员运算: 基本数据类型 1.数字 int(整型) 在32位机器上,整数的位数为32位,取值范围为-2**31-2**31-1,即-2147483648-2147483

Python之路【第三篇】:Python基础(二)

Python之路[第三篇]:Python基础(二) 内置函数 一 详细见python文档,猛击这里 文件操作 操作文件时,一般需要经历如下步骤: 打开文件 操作文件 一.打开文件 1 文件句柄 = file('文件路径', '模式') 注:python中打开文件有两种方式,即:open(...) 和  file(...) ,本质上前者在内部会调用后者来进行文件操作,推荐使用 open. 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作.

Python基础之二:数据类型

四.Python数据类型 数字 字符串 列表 元祖 字典 1.数字类型 整型 表示范围:-2147483648到2147483647,超过该范围的会被当作长整型 示例:num=123 type(num)-返回<type 'int'>,用来测试变量的类型 长整型 表示范围:任意大整数,后跟L或l与整型区别 示例:num=1l type(num)-返回<type 'long'> 浮点型 示例:num=12.0 type(num) -返回<type'float'> 复数型 示

Python 基础语法(二)

Python 基础语法(二) --------------------------------------------接 Python 基础语法(一) -------------------------------------------- 2. 元组 tuple和list十分相似,但是tuple是不可变的,即不能修改tuple,元组通过圆括号中用逗号分割的项定义:支持索引和切片操作:可以使用 in 查看一个元素是否在tuple中.空元组():只含有一个元素的元组("a",) #需要加

C++重点知识点(基础系列二)

C++重点知识点基类 C++重点知识点(基础系列二),布布扣,bubuko.com

python基础系列教程——Python3.x标准模块库目录

python基础系列教程——Python3.x标准模块库目录 文本 string:通用字符串操作 re:正则表达式操作 difflib:差异计算工具 textwrap:文本填充 unicodedata:Unicode字符数据库 stringprep:互联网字符串准备工具 readline:GNU按行读取接口 rlcompleter:GNU按行读取的实现函数 二进制数据 struct:将字节解析为打包的二进制数据 codecs:注册表与基类的编解码器 数据类型 datetime:基于日期与时间工具

python基础系列(二)----各数据类型的详细方法描述

python基础 一.整数 1 class int(object): 2 """ 3 int(x=0) -> int or long 4 int(x, base=10) -> int or long 5 6 Convert a number or string to an integer, or return 0 if no arguments 7 are given. If x is floating point, the conversion truncate

.Net程序员之Python基础教程学习----列表和元组 [First Day]

一. 通用序列操作: 其实对于列表,元组 都属于序列化数据,可以通过下表来访问的.下面就来看看序列的基本操作吧. 1.1 索引: 序列中的所有元素的下标是从0开始递增的. 如果索引的长度的是N,那么所以的范围是-N~N-1之间,超过这个范围就会提示 IndexError:  index out of range >>> greeting ='Hello world' >>> print greeting Hello world >>> print gr

python基础知识之列表、元祖、字典/字符串。

基础知识之列表: 列表用 [  ]来定义是可变的,可以通过索引值来去查询里面的字段可以可以追加,删除. 常用用法如下 names = ['zhang', 'zhuang', ['alx', 'bob'], 'chen', 'qiang'] print(len(names)) # 获取列表长度 print("aaffaa".count("a")) # 获取a在字符串出现的次数 print(names[1:3]) # 切片 print(names[-1]) # 获取最后