Python基础语法 | 易学教程

阅读目录：

　　第一节：编程基础

　　第二节：语言分类

　　第三节：高级语言的发展

　　第四节：程序program

　　第五节：Python解释器

　　第六节：Python基础语法

　　第七节：程序控制

　　第八节：额外扩展（以后会有介绍）

　　第九节：内置数据结构-数值and列表

内容：

第一节：编程基础

　　1、程序：

　　　　一组能让计算机识别和执行的指令

　　2、现代计算机结构体系-冯诺依曼体系架构　　

　　　　　　CPU由运算器和控制器组成　　　　　　

　　　　　　运算器，完成各种算数运算、逻辑运算、数据传输等数据加工处理

　　　　　　控制器，控制程序的执行
　　　　　　存储器，用于记忆程序和数据，例如内存
　　　　　　输入设备，将数据或者程序输入到计算机中，例
　　　　　　如键盘、鼠标
　　　　　　输出设备，将数据或程序的处理结果展示给用户，
　　　　　　例如显示器、打印机等

　　3、计算机语言：

　　　　人与计算机之间的交互的语言

　　4、机器语言：

　　　　一定位数组成二进制的0和1的序列，称为机器指令，机器指令的结合就是机器语言

　　5、汇编语言：

　　　　用一些助记符号代替机器指令，称为汇编语言，如：ADD A B将寄存器A 的数和寄存器B的数相加的数放到寄存器A 中

　　　　汇编语言写好的程序需要汇编程序转换成机器指令

第二节：语言分类

　　1、低级语言：

　　　　面向机器的语言，包括机器语言，汇编语言

　　　　不同的机器不能通用，不同的机器需要不同的机器指令或汇编程序

　　2、高级语言：

　　　　接近自然和数学语言的计算机语言

　　　　高级语言手写要书写源程序，通过编译程序吧源程序转换成机器的指令程序　　　　

　　3、编译语言和解释语言的区别：

　　　　编译语言：把源代码转换成目标机器的cpu指令

　　　　解释语言：解释后转换成字节码，运行在虚拟机上，解释器执行中间码

　　　　如：C 、C++等语言的源代码需要本地编译

　　　　　　java、Pyhton、C#的源代码需要被解释器编译成中间码（Bytecode）,在虚拟机上运行

第三节：高级语言的发展

　　1、非结构化语言：

　　　　编号或标签，GOTO，子程序可以有多个入口和出口如：ADD A B将寄存器A 的数和寄存器B的数相加的数放到寄存器A 中

　　　　有分支，循环

　　2、结构化语言：

　　　　任何基本结构只允许是唯一入口或出口

　　　　有顺序，分支，循环，废弃GOTO

　　3、面向对象语言

　　　　更加接近人类认知世界的方式，万事万物抽象成对象，对象间关系抽象成类和继承

　　　　封装、继承、多态

　　4、函数式语言：

　　　　古老的编程范式，用用在数学奇数，并行处理的场景，引入到了很多现代高级语言中。

第四节：程序program

　　1、程序：

　　　　程序= 算法+数据结构

　　　　数据一切程序的核心

第五节：Python解释器：

　　官方CPython：C语言开发，最广泛的Python解释器

　　IPython：一个交互式，功能增强的Cpython

　　PyPy：Python语言写的Python解释器，JIT技术，动态编译Pyhton代码

　　Jython：Python的源代码编译成java的字节码，跑在JVM

　　IronPython：与Jython类似，运行在.NET平台上的解释器，Python代码被编译成.NET字节码

第六节：Python基础语法

　　1、关于编码：

　　　　在Python中需要插入： #-*-conding:utf-8-*- ,Python3默认使用unicode编码。

　　　　gbk 两个字节表示一个字符，utf-8 三个字节表示一个字符，unicode至少两个字节。

　　　　gbk 和 utf-8 之间不能直接转换，必须通过unicode

　　2、注释：

　　　　单行注释使用： # 被注释内容

　　　　多行注释使用：　''' 被注释内容 '''

　　3、pyc文件：

　　　　执行Python代码时，如果导入了其他的.py文件，那么执行过程中会自动产生一个与其同名的.pyc文件，该文件就是Python解释器编译之后产生的字节码。

　　　　注：字节码通过反编译可以得到代码。

　　4、变量：

　　　　a、声明变量：

1 name = 'JerryZao' # name是一个变量，JerryZao是变量的值

　　　　b、理解变量在内存中的变现形式

　　　　　　name1 = ‘jack’

　　　　　　给name1赋值的时候，在内存中开辟一个空间，而name1 则是存放在jack的内存地址（可以用id（）查看）

　　　　c、变量的定义规则：

　　　　　　只能用字母，数字，下划线，不能以数字开头，不能使用关键字

　　5、Python的语言类型：

　　　　a、python是动态语言，强类型语言

　　　　　　1）静态编译语言：

　　　　　　　　实现声明变量类型，类型不能再改变，如：int a = 10

　　　　　　　　编译时检查

　　　　　　2）动态编译语言：

　　　　　　　　不用事先声明类型，随时可以复制为其他类型

　　　　　　　　编译时不知道是什么类型，很难判断

　　　　　　3）强类型语言：

　　　　　　　　不同类型之间的操作，必须先强制类型转换为同一类型，如： print（‘a’ + str (1)）

　　　　　　4) 弱类型语言：

　　　　　　　　不同类型间可以操作，自动隐式转换，如：js中 console.log(1 + 'a')

　　6、数字：

　　　　在Python中不区分long 和 int ，所有的整形 int

　　　　　　整数，bool（True，False），浮点数，复数

 1 num = '0011'
 2 v = int(num,base = 16) # 0011作为16进制数，转换为10进制数
 3 y = int(num,base = 10)
 4 z = int(num,base = 2)
 5 print(v,y,z)
 6 
 7 17 11 3
 8 
 9 
10 num = '24'
11 v = int(num,base = 16)
12 y = int(num,base = 10)
13 #z = int(num,base = 2) #错，2进制没有大于1 的数字
14 print(v,y)
15 
16 36  24

　　7、字符串

　　　　使用 ' " 单双引号用的字符的序列

　　　　''' 和 """单双三引号，可以跨行、可以在其中自由的使用单双引号

　　　　在字符串前面加上R 或 r 前缀，表示该字符串不做特殊处理

　　8、转义序列

　　　　\\ 　　\t　　　\　　r　　\n　　\'　　\"

　　　　前缀 r ，把里面的所有字符当作普通字符对待

　　9、缩进：

　　　　未使用C等语言的花括号，而是采用缩进的方式表示层次关系

　　　　约定使用4个空格

　　10、续航

　　　　在行尾使用\ ，如果使用各种括号，认为括号内是一个整体，不需要使用\

　　11、运算符：

　　　　a、算数运算符：

　　　　　　+ - * / ** // %

　　　　　　** ：求幂

　　　　　　// ：整除，返回商的整数部分

　　　　　　% ：求余

　　　　b：成员运算符：

　　　　　　in 、 not in

1 'a' in 'sadsa'
2 
3 True

　　　　c、比较运算符：

　　　　　　==　　> < <= >=

　　　　　　!= 、 <> ：表示不等于

　　　　d、逻辑运算符：

　　　　　　and 、 or 、not

　　　　e、赋值运算符：

　　　　　　= += -= += /= **= //= %=

　　　　f、位运算符：

　　　　　　& ：按位与

　　　　　　| ：按位或

　　　　　　~ ：按位取反

1 0000  1100    12
2 1111  0011    补码  -1
3 1000  1101    原码 -13
4 
5 12按位取反，是1111 0011 在计算器中认为这是补码，最高位1 ，就是负数，但是人要看原码，在补码一次，1000 1101

　　　　　　^ ：异或（异则为 1）

　　　　　　<< ：左移

1 a = -1 << 2
2 print(a)
3 
4 -4

1 print(~12)  13

　　　　注：　　　　　

　　　　　　is 和 "=="的区别:

　　　　　　== 判断左右两边的值是否相等

　　　　　　is 判断内存地址是否相等, id()值来判断

　　　　　　小数据池 (常量池),会对字符串进行缓存,为了节省空间,id一样. str boor int 有小数据池

　　　　　　"在python中如果单纯定义一个字符串会被添加到小数据池中"

　　12、原码、反码、补码、负数

　　　　1）反码：正数的反码是原码本身，负数的反码符号为不变其余按位取反

　　　　2）补码：正数的补码的原码本身，负数的补码符号位不变其余为按位取反后+1　　　

1 5-1
2 5的原码+ -1 的补码

 1 10 ^ 9
 2 
 3 0000 1010    10
 4 0000 1001     9
 5 0000 0011     3
 6 
 7 10^-9
 8 
 9 0000 1100
10 1000 1001   -9反码
11 1111 0111   -9补码
12 1111  1101    异或的补码
13 1000  0011

　　　13、运算符优先级：

　　　　算数运算符 > 位运算符> 身份（成员）运算符 > 成员运算符 > 逻辑运算符

第七节：程序控制

　　1、常用控制结构：顺序，分支，循环

　　2、单分支结构　　　　　

1 if conditon:
2     代码块
3     condition必须是一个bool类型，这个地方有一个隐式转换bool（condition）
4 
5 代码块：
6     类似于if 语句的冒号后面的就是一个语句块
7     在if、for 、def、class等关键字后使用代码块

　　3、多分支结构：

 1  if...elif...else语句
 2 if condition1:
 3     代码块1
 4 elif condition2:
 5     代码块2
 6 elif condition3:
 7     代码块3
 8 ......
 9 else:
10     代码块

　　4、分支嵌套：

 1 score = 80
 2 if score<0:
 3     print('wrong')
 4 else:
 5     if score==0:
 6         print('egg')
 7     elif score <= 100:
 8         print('right')
 9     else:
10         print('too big')

　　5、循环语句——while语句

1  语法
2 while condition:
3     block
4 当条件满足即condition为True，进入循环体，执行block
5 举例
6 flag=10
7 while flag:
8     print(flag)
9     flag -= 1

　　6、循环——for语句

1  语法
2 for element in iteratable:
3     block
4 当可迭代对象中有元素可以迭代，进入循环体，执行block

　　　　注：

　　　　　　a、range（）函数：　　　　　　　　　

　　　　　　　　a = range(1,4)
　　　　　　　　print(a)

　　　　　　　　a 是一个可迭代对象

 1 a = range(1,8,2)
 2 b = range(1,8,-1)
 3 c = range(8,1,-1)
 4 d = range(0)
 5 
 6 for i in c:
 7     print(i)
 8 
 9 8
10 7
11 6
12 5
13 4
14 3
15 2

　　7、循环continue语句

　　8、循环 break语句

1 count = 0
2 for i in range(0,1000,7):
3     print(i)
4     count += 1
5     if count >= 20:
6         break

示例

输出

　　　总结：
　　　　　　continue和break是循环的控制语句，只影响当前循环，包括while、for循环
　　　　　　如果循环嵌套， continue和break也只影响语句所在的那一层循环
　　　　　　continue和break 不是跳出语句块，所以 if cond: break 不是跳出if，而是终止if外的break所
　　　　　　在的循环

第八节：额外扩展（以后会有介绍）

　　1、引用计数：　　

1 import sys
2 
3 sys.getrefcount(x)

　　2、内置函数divmod()

　　　　divmod(54321,10000)

　　　　----> (5, 4321)

1 divmod(x, y, /)
2     Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.

　　3、判断是否是偶数的方式

1  i & 1 按位与，奇数的话，各位肯定是1，偶数各位肯定是0

第九节：内置数据结构-数值and列表

　　1、分类：

- - 数值型

　　　　　　　　　　int、 float、complex（复数，不常用），boo

- - 序列对象

　　　　　　　　　　字符串str、列表list 、元组tuple

- - 键值对

　　　　　　　　　　集合set、字典dict

　　*2、数值型：

- 数值型

　　　　　　　　int，float，complex。bool都是class，而具体的数据 1,2.2等都是对象即实例。

　　　　　　　　注：bool是 int 的子类，仅有True 和 False 对应1 、0，可以和整数直接运算

- 类型转换（built-in）

　　　　　　　　int(x),float(x),complex(x), bool(x)

　　3、数字的处理函数：

　　　　首先导入 math 模块，使用 round() ,floor(), ceil() int() //

 1 a = int(2.5)
 2 b = int(2.1)
 3 c = int(2.6)
 4 d = int(-2.4)
 5 e = int(-2.5)
 6 f = int(-2.7)
 7 print(a,b,c,d,e,f)
 8 
 9 2 2 2 -2 -2 -2
10 
11 # int 就是对浮点数取整数部分

int 对浮点数的处理

1 import math
2 
3 print(math.floor(2.5),math.floor(-2.5)) # 向地板 2 -3
4 print(math.ceil(2.5),math.ceil(-2.5)) # 向天花板 3 -2

floor和ceil的区别

1 print(7//2,7//-2,-7//2,-(7//2)) # 向下取整  3 -4 -4 -3
2 print(2//3,-2//3,-1//3) # 0 -1 -1

// 的取整放向

1 print(round(2.5),round(2.5001),round(2.6)) # 2 3 3 四舍六入五取偶（取偶是取离其最近的偶数）
2 （不是严格的四舍六入，只要大于5就入，小于5就舍）

round（）取整

　　4、数字的处理函数

　　　　　　min（）、max（）、pow（）== x**y、math.sqrt() 开方

　　　　　　进制函数，返回值是字符串：bin() oct() hex()

　　　　　　math.pi -----π math.e 自如常数

1 bin(2) # '0b10' 是字符串
2 oct(8) # '0o10'
3 0x10 # 16 是数字 int

import math
math.sqrt(9)

3.0  得到的是浮点数

　　5、类型判断：

　　　　　　type（obj），返回类型，而不是字符串　

a = 1
type(a)

得到str，但是 str  没有引号！！ 是 str 类

1 type(1 + True + 2.1) # float 
2 
3 type(True+ 1) # int

　　　　　　注：

　　　　　　　　只要有浮点数，就有隐式转换，变为 float 型

　　　　　　　　不同的类型之间不能比较，但是可以用 == 或！=

　　　　　　isinstance(obj,class_or_tuple):返回bool值

1 isinstance('a',str) # True
2 isinstance(1,(str,bool))# False bool虽然是int的子集，但是也不对
3 isinstance(1,(str,bool,int)) # True

1 In [61]: isinstance(1,bool)
2 Out[61]: False
3 
4 In [62]: isinstance(False ,bool)
5 Out[62]: True
6 
7 In [63]: isinstance(False , int)
8 Out[63]: True

　　　*6、列表 list

　　　　　　列表的特点：

- - 列表内的个体称为元素，由若干个元素组成列表
  - 元素可以是任意的
  - 列表内元素有顺序，可以索引
  - 列表的元素可以被迭代
  - 线性的数据结构
  - 使用 [ ] 表示
  - 列表是可变的

　　　　　　列表list 、链表 linked、队列queue、 stack栈的差异：

- - 列表：连续的内存空间，有序的，可索引的，追加（O(1)），查询都很快(通过索引值，偏移量），但是删除、增加元素，比较慢，需要遍历元素
  - 链表：非连续的内存空间，但是也是有序的，可以索引（在内存空间中是散落的，但是内存地址不是连续的），查询比较慢，都得从开头找，插队，删除都比较快，只需要找前后的内存地址就可以。
  - 队列：先进先出，基于地址指正遍历数据可以从进的一端或者出的一端，但是不能同时访问，不需要开辟新的空间
  - 栈：后进先出，遍历数据只能从入口端遍历，如果查找一个最先放进去的数据，需要遍历所有的数据，同时遍历数据需要开辟新的内存空间

　　　　　　列表定义，初始化：

　　　　　　　　方法一：[ ]

　　　　　　　　方法二：list(iterable) 　　

　　　　　　　　注：列表不能一开始就定义大小，但是会有一个大概的内存空间。

1 l = list()
2 l = []
3 l = [2,3,4,[2,3,4]]
4 l = list(range(5))

　　　　　列表索引访问：

　　　　　　　　索引，也叫下标

　　　　　　　　正索引：从左到右，从0开始

　　　　　　　　负索引：从右到左，从-1开始

　　　　　　　　索引都不可以越界，否则会出现IndexError

　　　　　　　　列表通过索引访问：list [index]

1 l = list(range(5)) # [0, 1, 2, 3, 4]
2 print(l[-2]) # 3

　　　　　　列表查询：

　　　　　　　　index（value,[ start,[stop ] ]） # a = l.index(4,6,8) ,6 和 8是索引，但是这里不能用负数做索引

　　　　　　　　　　通过值value ，从指定区间查找列表内的元素是否匹配

　　　　　　　　　　匹配到第一个就立即返回索引

　　　　　　　　　　匹配不到，抛出ValueError 异常

1 l = list(range(1,5))  [1,2,3,4]
2 a = l.index(1)
3 print(a) # 0

　　　　　　　　count(value)

　　　　　　　　　　返回列表中匹配Value的次数, 如果 value 不存在，不会抛异常

1 l = list(range(1,5)) 
2 b = l.count(5)
3 print(b) # 0

　　　　　　　　时间复杂度：

　　　　　　　　　　index 和 count 方法都是O(n)

　　　　　　　　　　随着列表数据规模的增大，而效率下降,而且两者都要遍历，所以一般都少用！！！！

　　　　　　　　　　n：元素的个数

　　　　　　　　　　O(1)：表示一步到位，如后面说的append（）

　　　　　　　　返回列表元素的个数：

　　　　　　　　　　len(l)：默认不需要遍历，会在列表最后有记录

　　　　　　　　注：有顺序的可以索引，但不一定可以迭代

　　　　　　列表元素修改：

　　　　　　　　索引访问修改：

　　　　　　　　　　list [ index ] = value 注：index不能越界，抛出 IndexError异常

1 l = [1,2,3,4]
2 l[2] = 333
3 print(l)  # [1, 2, 333, 4]

　　　　　　列表增加、插入元素：(一次只能插，追加一个元素)

　　　　　　　　append（object）返回 None，也就意味着在原列表追加，时间复杂度为O(1)，一步到位。

　　　　　　　　insert（index,obj）返回None，时间复杂度为 O(n)，所以少用。

　　　　　　　　注：所以可以越界，越上界，尾部追加，否则，首部追加，没有任何意义！

 1 l = [1,2,3,4]
 2 l.append('a') # append()是把任何当成一个具体对象，直接追加到最后，而且只能表示为一个，否则抛出SyntaxError
 3 l.append(range(5))  
 4 l.append([2,3,3])
 5 print(l) # [1, 2, 3, 4, 'a', range(0, 5), [2, 3, 3]]
 6 
 7 
 8 
 9 l = [1,2,3,4]
10 l.insert(0,2)
11 l.insert(3,[2,3,4])
12 print(l) # [2, 1, 2, [2, 3, 4], 3, 4]

　　　　　　　　extend（iteratable）返回None

1 l = [1,2,3,4,4,4,435,4,35,435,3]
2 l.extend(range(5))
3 print(l) # [1, 2, 3, 4, 4, 4, 435, 4, 35, 435, 3, 0, 1, 2, 3, 4]

　　　　　　　　+ 生成新的 list

1 l = [1,2,3,4,35,435,3]
2 a = l + [55,55]
3 print(a) # [1, 2, 3, 4, 35, 435, 3, 55, 55]
4 print(l) # [1, 2, 3, 4, 35, 435, 3]

　　　　　　　　* 生成新的list

1 l = [1,2,3,4,35,435,3]
2 a = l * 2
3 print(a) # [1, 2, 3, 4, 35, 435, 3, 1, 2, 3, 4, 35, 435, 3]
4 print(l) # [1, 2, 3, 4, 35, 435, 3]

　　　　　　　　注： * 使用的坑：　　　

1 x = [[1,2,3]]*2
2 print(x) # [[1, 2, 3], [1, 2, 3]]
3 print(x[1][2]) # 3
4 
5 y = [1] * 5
6 print(y) # [1, 1, 1, 1, 1]

　　　　　　　　注：关于 *

 1 l1 = [1,2,3,3] 
 2 l2 = l1 * 3
 3 l1[2] = 0
 4 l2[2] = 0
 5 print(l1)
 6 print(l2)
 7 ----------------------->
 8 [1, 2, 0, 3]
 9 [1, 2, 0, 3, 1, 2, 3, 3, 1, 2, 3, 3]
10 
11 
12 
13 l1 = [[1,2]] # 里边的 [1,2]是一个地址引用，放的是地址，所以乘3 就是地址复制三分（不同于上面例子，单个简单元素）
14 l2 =  l1 * 3
15 l2[1][1] = 6
16 print(l2)
17 ----------------------->
18 [[1, 6], [1, 6], [1, 6]]

　　　l2[2] = 99
　　　print(l2) # [[1, 2], [1, 2], 99]

19 
20 
21 l1 = [[1,2],[1,2],[1,2]] # 因为不是同一个地址，不像上面，*3 形成，所以只改一个
22 l1[2][1] = 6
23 print(l1)
24 ----------------------->
25 [[1, 2], [1, 2], [1, 6]]

　　　　　　列表删除元素：

　　　　　　　　remove(value) ：返回None，在原列表删除,O(n)

　　　　　　　　pop（[ index ]）-- item

　　　　　　　　　　　　不指定索引，就从列表的尾部弹出一个元素

　　　　　　　　　　　　指定索引，就从索引弹出一个元素，索引越界抛出IndexError

　　　　　　　　clear（）--- 返回None

　　　　　　　　　　　　清除列表的所有元素，剩下一个空列表

　　　　　　列表的其他操作：

　　　　　　　　reverse() ：返回None

　　　　　　　　　　　　将列表元素反转，就地修改

　　　　　　　　sort( key = None,reverse = False) 返回None

　　　　　　　　　　　　对列表元素进行排序，就地修改，默认升序

　　　　　　　　　　　　reverse = True ，反转，降序

　　　　　　　　　　　　key 一个函数，指定key 如何排序

　　　　　　　　　　　　　　　　lsi.sort(key = functionname)

　　　　　　　　　　　　　　　　sort(key=str,reverse=True) # 元素以str 排序

　　　　　　　　　　　　in : [3,4] in [1,2,[3,4]] , for x in [1,2,3,4]

　　　　　　　　注:Python中是没有变量的！

　　　　　　随机数：random模块

　　　　　　　 random.randint() # 闭区间的整数 random.randint(2,3) ,返回int类型

　　　　　　　　random.randrange() # 左闭右开 random.range(1,7,2)，返回int类型

　　　　　　　　random.choice(iteration) # 随机去一个，但是原数据集不变

1 l = [1,2,34,4,'s']
2 print(random.choice(l))
3 print(l)

　　　　　　　　random.shuffle() # 就地修改，返回None，（洗牌，打乱）

1 l = [1,2,34,4,'s']
2 print(random.shuffle(l))
3 print(l)
4 
5 None
6 [2, 4, 34, 1, 's']

　　　　　　　　random.sample(ierater，k) # 取k个不同的元素 (理解这里的不同：l[1] = l[2] ,但是是不同的元素），返回一个新列表

　　　　　　　　　　　　random.sample(['a','b','c','d'],2)

　　　　　　　　　　　　random.sample(['a','a','a'],2) # ['a','a']

1 l = [1,2,3,4,2,2,2,2,2,34,4,'s']
2 print(random.sample(l,3))
3 print(l)
4 
5 [2, 2, 4]
6 [1, 2, 3, 4, 2, 2, 2, 2, 2, 34, 4, 's']

　　　　　　**列表的复制：浅复制，深复制　　　

　　　　　　　　　　　　---------------------> 赋值

1 l1 = list(range(5))
2 l2 = list(range(5))
3 print(l1 == l2) #  ==  内容相同
4 l3 = l1
5 l1[2] = 9
6 print(l3)
7 ---------------------->
8 True
9 [0, 1, 9, 3, 4]

In [106]: l1 = [1,2,3,[4,5]]

In [107]: l2 = l1

In [108]: l2[1] = 22

In [109]: l2[3][1] = 55

In [110]: l1
Out[110]: [1, 22, 3, [4, 55]]

In [111]: l2
Out[111]: [1, 22, 3, [4, 55]]

　　　　　　　　------> copy,生成新的列表（shadow copy 影子拷贝）

 1 l1 = list(range(4))
 2 l2 = l1.copy()
 3 print(l2)
 4 l2[2] = 99
 5 print(l1,l2)  # [0, 1, 2, 3] [0, 1, 99, 3]
 6 
 7 l3 = [1,2,3,[5,6]]
 8 l4 = l3.copy()
 9 print(l4)
10 # l3[3] = 10
11 # print(l3,l4) # [1, 2, 3, 10] [1, 2, 3, [5, 6]]
12 l3[3][1] = 9
13 print(l3,l4) # [1, 2, 3, [5, 9]] [1, 2, 3, [5, 9]]

　　　　　　　　------> deepcopy,深拷贝

 1 import copy
 2 l1 = [1,2,3]
 3 l2 = copy.deepcopy(l1)
 4 # print(l2)
 5 l2[2] = 99
 6 # print(l2) [1, 2, 99]
 7 l3 = [1,2,[3,4]]
 8 l4 = copy.deepcopy(l3)
 9 print(l4)
10 l3[2][1] = 99
11 print(l3,l4) # [1, 2, [3, 99]] [1, 2, [3, 4]]
12 
13 l3[2] = 999
14 print(l3,l4) #[1, 2, 999] [1, 2, [3, 4]]

列表补充：

　　1、切片：

 1 li = [1, 12, 3, 4, [2, 2, [3, 4]], 2, '232', 'dsd']
 2 a = li[0]
 3 print(a)
 4 b = li[0:1]
 5 print(b)
 6 c = li[0:-1]
 7 print(c)
 8 d = li[0:5:2] #从左往右隔一个取值
 9 print(d)
10 e = li[-1::-1] #从右往左一个一个取
11 print(e)
12 f = li[-1::-2] # 从右往左隔一个取
13 print(f)
14 g = li[-1::-3]
15 print(g)
16 h = li[1:]
17 print(h)
18 i = li[:]
19 print(i)
20 
21 1
22 [1]
23 [1, 12, 3, 4, [2, 2, [3, 4]], 2, '232']
24 [1, 3, [2, 2, [3, 4]]]
25 ['dsd', '232', 2, [2, 2, [3, 4]], 4, 3, 12, 1]
26 ['dsd', 2, 4, 12]
27 ['dsd', [2, 2, [3, 4]], 12]
28 [12, 3, 4, [2, 2, [3, 4]], 2, '232', 'dsd']
29 [1, 12, 3, 4, [2, 2, [3, 4]], 2, '232', 'dsd']

　　2、连接成字符串：（全是字符串的元素才可以）

1 li1 = ['ww','wwwq','wqw']
2 s = ''.join(li1)
3 print(s)
4 
5 wwwwwqwqw

元组也可以：

tu = ('ss','we',)
s = ''.join(tu)
print(s)

　　3、del 删除元素

1 a = [1,2,3,4]
2 del a[1]
3 print(a)

[1, 3, 4]

　　注：del是根据索引删除元素，remove是根据元素删除，从左往右，第一个匹配到的

　　4、列表如何转换为字符串：

列表转换为字符串，在列表基本操作里介绍了
tu = (11, 22, 33, [9, 3], 44,)
s = ''
for i in tu:
    s = s + str(i)
print(s)
print(type(s)) # <class 'str'>

来源：oschina

链接：https://my.oschina.net/u/4263192/blog/3885393

标签

java

python

jython

.Net Framework

cpython