pyt是什么意思在线翻译读音例句

Python基础知识点总结

Python基础知识与常用数据类型

一、Python概述：

1.1、Python的特点：

1、Python是一门面向对象的语言，在Python中一切皆对象

2、Python是一门解释性语言

3、Python是一门交互式语言，即其在终端中进行命令编程

4、Python是一门跨平台的语言【没有操作系统的限制，在任何操作系统上都可以运行Python代码】

5、Python拥有强大和丰富的库，又被称为胶水语言，能把其他语言（主要c/c++）写的模块很轻松的结合在一起

1.2、Python的优缺点：

1、优点：

a、易于维护和学习

b、广泛的标准库【提供了大量的工具】

c、可扩展性

d、Python对于大多数据库都有相应的接口【Mysql、sqlites3、MongoDB、Redis等】

e、支持GUI编程【图形化界面】

f、语法简单，易于学习

2、缺点：

a、和C语言相比较Python的代码运行速度慢

b、代码无法加密

1.3、Python代码的执行过程：

大致流程：源码编译为字节码（.pyc)----->Python虚拟机------->执行编译好的字节码----->Python虚拟机将字节码翻译成相对应的机器指令（机器码）。

Python程序运行时，先编译字节码并保存到内存中，当程序运行结束后，Python解释李白唐诗大全集一千首 器将内存中的字节码对象写到.pyc文件中。

第二次再运行时，先从硬盘中寻找.pyc文件，如果找到，则直接载入，否则重复上面过程。

优点：不重复编译，提高执行效率

二、Python中的基础语法：

2.1、Python中变量在内存中的存储

2.1.1引用和对象：

对象：当创建数据对象时，在内存中会保存对象的值，这个值就是对象自己；

引用：对象保存在内存空间，外部想要使用对象的值，就需要使用引用来操作对象。内存中会保存对象引用的数量，当某个对象的引用为0时，对象会被回收。

2.1.2可变数据类型和不可变数据类型

a、数据分类：

可变数据对象：列表（list）和字典（dict）

不可变数据对象：整型（int）、浮点型（float）、字符串（string）和元组类型（tuple）

注：此处的可变和不可变，是指内存中的对象（Value）是否可以改变，对于不可变类型的对象，在对对象操作的时候，必须在内存中重新申请一块新的区域，即重新给一个新的地址用于存储；对于可变类型的对象，

的地址后面继续申请即可，即address并不会改变，而是address的区域的大小会变长或变短。

不可变数据类型：对象本身的值不可变，如果改变了变量的值，相当于新建了一个对象，而对于相同值的对象，在内存中只有一个对象。

可变数据类型：允许变量的值进行改变，对于变量给值的过程中，只是改变了变量的值，而不会新建一个对象，所以可变数据类型的意思就是说对一个变量进行操作时，其值是可变的，值的变化并不会引起新建对象，

充。，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

2.1.3引用传递和值传递（函数传值）

说明：可变对象为引用传递，不可变对象为值传递

引用传递：传递列表或者字典时，如果改变引用的值，就修改了原始的对象

defcheck(l):

print(l)

print(id(l))

([1,23,2,3,4])

returnl

l=[1,2,3,4]

print(check(l))

print(id(l))

\'\'\'

[1,2,3,4]

29

[1,2,3,4,[1,23,2,3,4]]

29

\'\'\'

值传递：当传递不可变对象时，如果改变引用变量的值，只是创建了不同的对象，原始对象并没有改变。

defcheck(s):

print(s)

print(id(s))

s=\"iamtest\"

print(id(s))

returns

s=\"Thisisatest\"

print(check(s))

print(s)

\'\'\'

Thisisatest

24

24

iamtest

Thisisatest

\'\'\'

\'\'\'

2.1.4深拷贝和浅拷贝

浅拷贝：语法：()，浅拷贝是创建了一个和原对象一样的类型，但是其内容是对原对象元素的引用。

深拷贝：语法：py(),在内存中将所有的数据重新建立一份。

变量的本质：在内存中开辟了一块空间，其中存储了指定类型的数据【实体（对象）存储在堆中，变量（引用）存储在栈空间中

2.2基本数据类型

Python中常用的数据类型有：整型（int）、浮点型（float）、字符串（string）、空值（None）、布尔值（True和False）、复数、类、函数等

Python中常量的命名规则使用变量名为全大写为常量

变量的命名遵循标识符的命名规则

2.3关键字、标识符和内置函数

1、关键字：在Python中被赋予了特殊含义的英文单词

Python中的关键字的查看使用keyword模块

importkeywordaskey

\'\'\'

[\'False\',\'None\',\'True\',\'and\',\'as\',\'assert\',\'break\',\'class\',\'continue\',\'def\',\'del\',\'elif\',\'else\',\'except\',\'finally\',\'for\',\'from\',\'global\',\'if\',\'import\',\'in\',\'is\',\'lambda\',\'nonlocal\',\'not\',

\'\'\'

2、标识符的命名规则：标识符的命名构成：数字、字母、下划线，但不能以数字开头，在标识符的命名中严格区分大小写

命名规范：

Python官方：所有单词全部小写，不同单词之间使用下划线分割，普遍是用驼峰命名法（小驼峰与大驼峰）

3、内置函数：

importsys

dir(s[\'__builin__\'])#错

内置函数表;

内置函数

abs()dict()help()min()setattr()

all()dir()hex()next()slice()

any()divmod()id()object()sorted()

ascii()enumerate()input()oct()staticmethod()

bin()eval()int()open()str()

bool()exec()isinstance()ord()sum()

bytearray()filter()issubclass()pow()super()

bytes()float()iter()print()tuple()

callable()format()len()property()type()

chr()frozenset()list()range()vars()

classmethod()getattr()locals()repr()zip()

compile()globals()map()reversed()import()

complex()hasattr()max()round()

delattr()hash()memoryview()set()

2.4Python运算符

2.4.1算术、赋值运算符：

**：求幂运算

//：整除运算或者成为地板除

%：取余运算

常用算数运算符的优先级：**>*>///%>+-

赋值运算符：=

复合运算符：+=、-=、*=、/=

关系比较：==、!=、>=、<=等

2.4.2逻辑运算

运算符逻辑表达式描述

andxandy布尔\"与\"-如果x为False，xandy返回False，否则它返回y的计算值。【

orxory布尔\"或\"-如果x是True，它返回x的值，否则它返回y的计算值。

notnotx布尔\"非\"-如果x为True，返回False。如果x为False，它返回True。

算符描述

&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

^按位异或运算符：当两对应的二进位相异时，结果为1

~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于-x-1。（运算原理：计算补码，按位取反，转为原码，末尾加1）

<<左移动运算符：运算数的各二进位全部左移若干位，由\"<<\"右边的数指定移动的位数，高位丢弃，低位补0。

>>右移动运算符：把\">>\"左边的运算数的各二进位全部右移若干位，\">>\"右边的数指定移动的位数

#位运算实例：x与y的数值的交换

#1、交叉赋值

x,y=y,x

#2、第三方变量

temp=x

x=y

y=temp

#3、异或

#规律：一个数异或另一个数两次之后的结果为该数本身

x=x^y

y=x^y

x=x^y

#4、加减法

x=x+y

y=x-y

x=x-y

2.4.3成员及身份运算：

成员运算符：in、notin

身份运算符：is、isnot

身份运算符：is、isnot

2.5Python中的语句

2.5.1if语句

if语句在Python中的两种结构为：

#1

if条件表达式：

代码块

#2

if条件表达式：

代码块

elif条件表达式：

代码块

#3

if条件表达式：

代码块

else：

代码块

2.5.2for语句

for变量in数据结构：

循环体

#9*9乘法表

foriinrange(1,10):

forjinrange(1,i+1):

print(\"%dx%d=%d\"%(j,i,i*j),end=\"\")

print(\"\")

2.5.3while语句

while条件表达式：

代码块

#9*9乘法表

whileline<10:

temp=1

whiletemp<=line:

print(\"%dx%d=%d\"%(temp,line,temp*line),end=\"\")

temp+=1

print(\"\")

line+=1

break：直接跳出当前循环

continue：结束当前正在执行的循环，继续下一次循环

三、Python内置数据结构：

Python中最基本的数据结构是序列（sequence），Python包含6中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。

3.1、String

3.1.1、字符串的创建

将文本放在单引号，双引号和三引号之间

>>>str1=\'hello,fanison\'

>>>type(str1)

str

3.1.2、字符串的转义：

字符串的转义使用r

3.1.3、字符串的切片操作

索引运算符s[i]返回一个序列的元素i

切片运算符s[i:j]返回一个在字符串中从第i个元素开始到j-1之间的元素

扩展切片运算符s[i:j:step]在字符串中以step的步长从第i个到j-1个元素之间的元素，step为正数表示正着取，i

len(s)s中的元素个数

min(s)s的最小值

max(s)s的最大值

3.1.4字符串的相关方法：

(sub[,start[,end]])找到指定字符串sub首次出现的位置

(str,beg=0,end=len(string))找到字符串sub首次出现位置，与index不同是不报错而返回-1

()将一个字符串转换为大写形式

()将一个字符串转化为小写形式

(t)使用s作为分隔符连接序列t中的字符串()将s两边不显示的符号去掉之后返回（lstrip、rstrip）

(t)获取以字符t将s切割的列表

()获取s的指定编码的bytes值

()获取bytes的对应编码的字符串，在python2中使用decode函数

th(suffix,beg=0,end=len(string))检查中是否以suffix字符串结尾

3.2list

变量：相当于是一个容器，每次只能存储一个数据

作用：相当于是一个容器，可以同时存储多个数据

本质：一种有序的集合【有序：数据的存放顺序和底层存储的顺序是相同】

列表中的元素本质存储的是一个变量【引用】，列表是可变的【一个列表一旦被定义，则在代码运行的过程中，其中的元素的值可以随时发生改变】

num=10

list1=[43,5,45,46,5]

list1=[43,5,45,46,5]

print(id(list1[0]))

list1[0]=100

#1.创建【定义一个列表类型的变量】

#命名方式：lxxlistxxx,不建议直接使用list

#其中允许存放重复元素

list1=[45,23,2,54,54,6]

print(list1)

#其中允许存放不同类型的数据

list2=[\"hello\",4637,False]

print(list2)

#列表元素的访问

#索引/下标/角标：取值范围：0~len(xx)-1或者-1~-（len(xxx)）

print(list1[3])

print(list1[-1])

#print(list1[20])#IndexError:listindexoutofrange列表下标越界

#列表元素的替换/修改

list1[3]=473

print(list1)

#组合:生成了一个新的列表

print(list1+list2)

print(list1)

#列表元素的重复

print(list1*3)

print(list1)

#判断某个元素是否在列表中

print(10inlist1)#False

print(10notinlist1)#True

print(45inlist1)#True

print(45notinlist1)#False

#列表切片【截取】：根据指定的列表获取子列表

list3=[45,23,2,473,54,6,5,6,56,5]

print(list3[2])

print(list3)

#格式：列表名[start：end：step]，包头不包尾

#获取从指定下标开始到结尾的元素组成的一个子列表

print(list3[2:])

#获取从开头到指定下标的元素。。。。

print(list3[:6])

#截取指定区间

print(list3[2:6])

#特殊情况1：如果end超出了下标的范围，则默认获取从指定下标开始到结尾的元素

print(list3[4:100])

#等价于

print(list3[4:])

#特殊情况2：step在默认情况下为1

print(list3[1:6:2])#1,3,5

print(list3[-1:-6])#当start和end都为负数，step为正数的时候，获取的结果为[]

print(list3[-1:-6:-2])#当start，end和step都为负数的时候，表示倒序

#将列表倒序输出

print(list3[-1::-1])

print(list3[::-1])

#列表系统功能

#1.添加元素

#1.1append，追加，在列表的末尾添加元素常用

l1=[22,33,44,55]

print(l1)

#追加单个元素

(66)

print(l1)

#追加多个元素，不能直接追加，通过列表的形式追加，形成了一个二维列表

#(77,88)#报错：TypeError:append()takesexactlyoneargument(2given)

([77,88])

print(l1)#结果：[22,33,44,55,66,[77,88]]

#1.2extend，扩展，在列表的末尾添加元素

l2=[22,33,44,55]

#追加单个元素,不能直接添加，参数一定是可迭代的

#(66)#T报错：ypeError:\'int\'objectisnotiterable

([66])

print(l2)

([77,88])

print(l2)#结果：[22,33,44,55,66,77,88]

\"\"\"

总结：

列表名.功能名(xx)

append可以直接添加单个元素，而extend不能

append在添加多个元素的时候，是以列表的形式添加，而extend只添加元素【打碎加入】

\"\"\"

#1.3insert，插入，在指定索引处插入一个元素，后面的元素向后顺延

#列表名.insert(索引，被插入的元素)

l3=[22,33,44,55]

#插入单个元素

(2,66)

print(l3)

#插入多个元素:和append类似，将整个列表直接插入

(1,[77,88])

print(l3)

#2.删除

#2.1pop,弹出,移除并获取列表中指定索引处的元素在栈中【列表的底层工作原理是栈】

list1=[11,22,33,44,55]

#注意：pop在默认情况下删除的是最后一个元素

result1=()

print(list1)

print(result1)

result2=(2)

print(list1)

#2.2remove，移除，直接操作的是元素

list2=[11,22,33,44,55,33,33,55]

(22)

print(list2)

#注意：移除指定元素在列表中第一次匹配到的元素【从左往右】

(33)

print(list2)

#2.3clear清除，将指定列表变为空列表使用场景：循环中，每次需要清空【重置】列表

()

print(list2)

#3.获取

list1=[54,6,57,5,57,7,6,7,57]

#3.1len(),获取列表长度

l=len(list1)

#3.2max(),获取列表中的最大值

#3.2max(),获取列表中的最大值

print(max(list1))

#3.3min()，获取列表中的最小值

print(min(list1))

#练习：模拟max或者min的功能，求三个数中的最大值

#假设法

num1=43

num2=437

num3=2

#定义一个变量，用于记录最大值

max1=num1

ifnum2>num1:

max1=num2

ifnum3>max1:

max1=num3

#3.4index()，获取指定元素在原列表中第一次匹配到的索引

print((57))

#模拟index的功能

foriinrange(len(list1)):

iflist1[i]==57:

print(i)

#3.5count(),统计个数，统计指定元素在列表中出现的次数

c=(57)

print(c)

list1=[54,6,57,5,57,7,6,7,57,57,57,436]

#练习：将list1中57给全部删除

#(57)

#(57)

#(57)

#print(list1)

#统计57在列表中出现的次数

num=57

c=(num)

n=1

whilen<=c:

(num)

n+=1

print(list1)

importcopy

#4.其他用法

#e,反转

list1=[35,4,5,4,654]

#print(list1[::-1])

#e(现代诗歌《小草》 )

#print(list1)

#4.2.1sort,排序,默认为升序,在列表内部进行排序

#列表名.sort()

#升序

#()

#print(list1)

#降序

#(reverse=True)

#print(list1)

#4.2.2sorted，排序,默认为升序，生成了一个新的列表

#sorted(列表名)

#升序

newList=sorted(list1)

print(list1)

print(newList)

#降序

newList2=sorted(list1,reverse=True)

print(newList2)

#根据元素的长度进行排序

list2=[\"gjsrghj\",\"545\",\"fhghg\",\"ahjegrhkwjhgrke\"]

#key关键字参数可以指定自定义的排序规则,格式：key=函数名

newList3=sorted(list2,key=len,reverse=True)

print(newList3)

#4.3copy,拷贝

#直接赋值，浅拷贝，栈空间层面上的拷贝【引用】

list1=[23,54,56]

list2=list1

list2[1]=100

print(list1)

print(list2)

print(id(list1)==id(list2))

#copy，深拷贝，堆空间层面上的拷贝【实体】

list1=[23,54,56]

list2=()

list2[1]=100

print(list1)

print(list2)

print(id(list1)==id(list2))

#模块copy，copy(),deeepcopy()【面试题】

#内容角度上的拷贝，copy只拷贝最外层，deepcopy可以拷贝内层的内容【二维列表中】

a=[1,2,3]

b=[4,5,6]

c=[a,b]

print(c)

d=(c)

print(id(d)==id(c))#False

e=py(c)

print(id(e)==id(c))#False

(4)

print(c)

print(d)#[[1,2,3,4],[4,5,6]]

print(e)#[[1,2,3],[4,5,6]]

\"\"\"

d:[[1,2,3],[4,5,6]]

[list1,list2]---->list1:[1,2,3]list2:[4,5,6]

\"\"\"

#4.4转换

#list(),tuple()

#二维列表：遍历

l1=[[11,22,33,44],[44,55,66]]

print(l1[0])#l1[0]=[11,22,33,44]

print(l1[0][2])

foriinl1:

forjini:

print(j)

forn1inrange(len(l1)):

forn2inrange(len(l1[n1])):

forn2inrange(len(l1[n1])):

print(l1[n1][n2])

3.3tuple

和列表类似，本质是一种有序的集合

元组和列表的不同之处：

a.定义不同：列表[]元组()

b.是否能够修改：列表可以进行增加或者删除元素的操作，但是，元组一旦被定义之后，其中的元素将不能进行任何的更改

#其中允许存储重复元素

t1=(23,53,54,53)

print(t1)

#其卓文君简介 中允许存储不同类型的数据

t2=(\"hello\",47,19.0,False)

print(t2)

#特殊情况:当一个元组中只有一个元素的之后，会被识别为一个普通变量

t3=(10)

print(type(t3))

print(t3)

#为了消除歧义，当元组中只有一个元素的时候，元组名=(元素,)

t4=(10,)

print(type(t4))

print(t4)

#元组元素的访问

#元组名[索引]

print(t2[1])

#t2[1]=100#报错：TypeError:\'tuple\'objectdoesnotsupportitemassignment【赋值】

#特殊情况：如果在元组中的元素是列表，则列表中的元素依旧可以修改

#【依据：元组和列表中存储都是变量的地址，元素不允许修改，只需要保证未发生改变即上枢密韩太尉书特殊句式 可其中的地址】

t5=(23,5,3,5,[235,345,5,45,4])

print(t5)

print(t5[4])#[235,345,5,45,4]

t5[4][1]=100

print(t5)

#列表和元组的遍历

#直接获取元素

forelementint5:

print(element)

#获取索引

foriinrange(len(t5)):

print(i,t5[i])

#同时遍历索引和元素

#需要将元组或者列表转换为枚举类型

#list(t5)

#注意：下面的i并不是元组或者列表的索引，而是枚举中的编号

fori,elementinenumerate(t5):

print(i,element)

3.4dict常用

也是一种存储数据的方式，但是字典是无序的，

类似于list或者tuple，但是，字典采用键-值对的方式存储数据

age1=10

list1=[10,4,35,46,6]

dict1={\"zhangsan\":10}

作用：具有极快的查找速度

键【key】相当于list或者tuple中的索引

key的特点

a.字典的key是唯一的【key不允许重复】

必须为不可变的数据

list是可变的，不能用来当做key

tuple，数字型，字符串，布尔值都是不可变的，可以被充当key

dict1={\"zhangsan\":10,\"lisi\":13,\"zhaoliu\":50}

#1.访问键值对

print(dict1[\"lisi\"])

#访问一个不存在的key，则报错

#print(dict1[\"abc\"])#KeyError:\'abc\'

#字典是可变的

dict1[\"zhaoliu\"]=100

result0=dict1[\"zhaoliu\"]

print(result0)

#字典名[key]=value

#注意：如果key存在，则表示修改value的值；如果key不存在，则表示在字典中添加一对新的键值对

dict1[\"abc\"]=20

print(dict1)

#get()

result1=(\"zhaoliu\")

print(result1)

#如果key不存在，则不会报错，返回None，一般用于判断

result2=(\"def\")

print(result2)

#2.删除，pop

#注意：删除指定的key，对应的value也会随着删除

(\"lisi\")

print(dict1)

#3.字典的遍历

#3.1直接遍历key掌握

forkeyindict1:

print(key,dict1[key])

#print(())

#print(type(()))#

():

print(key,dict1[key])

#3.2直接遍历value

():

print(value)

#3.3,遍历的是键值对的编号和key

fori,elementinenumerate(dict1):

print(i,element)

#3.4同时遍历key和value掌握

forkey,():

forkey,():

print(key,value)

\"\"\"

【面试题：dict和list之间的区别】

查找和插入的速度不会因为key-value的增多而变慢，

而list在每次查找的时候都是从头到尾进行遍历，当数据量大的时候，list速度肯定会变慢

需要占用大量的内存空间，内存浪费多，

而list只相当于存储了字典中的key或者value，并且list数据是紧密排列的

\"\"\"

练习：

\"\"\"\"

1.逐一显示列表l1=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]中索引为奇数的元素

2.将属于列表l1=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]，

但不属于列表l2=[\"Sun\",\"Mon\",\"Thu\",\"Fri\",\"Sat\"]的所有元素定义为关于中秋节的古诗简单 一个新列表l3

3.已知列表namelist=[\'stu1\',\'stu2\',\'stu3\',\'stu4\',\'stu5\',\'stu6\',\'stu7\']，删除列表removelist=[\'stu3\',\'stu7\',\'stu9\']；

请将属于removelist列表中的每个元素从namelist中移除(属于removelist，但不属于namelist的忽略即可)；

4.有一个字符串是一句英文，统计每个单词出现的次数，生成一个字典，单词作为key，次数作为value生成一个字典dict1

5.已知列表list1=[0,1,2,3,4,5,6],list2=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"],

以list1中的元素作为key，list2中的元素作为value生成一个字典dict2

\"\"\"

#1.

l1=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]

foriinrange(len(l1)):

ifi%2!=0:

print(l1[i])

#2.

#思路：遍历l1,获取l1中的元素，判断在l2中是否存在，如果不存在，则添加到一个新的列表中

l1=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]

l2=[\"Sun\",\"Mon\",\"Thu\",\"Fri\",\"Sat\"]

l3=[]

forele1inl1:

ifele1notinl2:

(ele1)

#3

#思路：遍历removelist,获取其中的元素，判断该元素在namelist中是否存在，如果存在，则删除

namelist=[\'stu1\',\'stu2\',\'stu3\',\'stu4\',\'stu5\',\'stu6\',\'stu7\']

removelist=[\'stu3\',\'stu7\',\'stu9\']

forele2inremovelist:

ifele2innamelist:

(ele2)

print(namelist)

#4

str1=\"todayisagooddaytodayisabaddaytodayisaniceday\"

dict1={}

#使用空格切割字符串

list1=(\"\")

print(list1)

#遍历列表，获取其中的每个单词

forwordinlist1:

#在字典中通过key获取value

c=(word)

ifc==None:

#不存在，添加键值对

dict1[word]=1

else:

#存在，则将value的值递增1

dict1[word]+=1

print(dict1)

#5.

list1=[0,1,2,3,4,5,6]

list2=[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]

dict2={}

#定义一个变量，作为list1和list2的索引

index1=0

iflen(list1)==len(list2):

whileindex1

#dict2[key]=value=======>dict2[list1中的元素]=list2中的元素

#list1[index1]list2[index1]

dict2[list1[index1]]=list2[index1]

index1+=1

eliflen(list1)>len(list2)长江之歌 :

whileindex1

dict2[list1[index1]]=list2[index1]

index1+=1

else:

whileindex1

dict2[list1[index1]]=list2[index1]

index1+=1

#优化上面的代码：封装【抽取】

\"\"\"

defcustom(num):

dict2[list1[num]]=list2[num]

num+=1

returnnum

#定义一个变量，作为list1和list2的索引

index1=0

iflen(list1)==len(list2):

whileindex1

#dict2[key]=value=======>dict2[list1中的元素]=list2中的元素

#list1[index1]list2[index1]

r=custom(index1)

index1=r

eliflen(list1)>len(list2):

whileindex1

r=custom(index1)

index1=r

else:

whileindex1

r=custom(index1)

index1=r

\"\"\"

print(dict2)

3.4set

集合：不允许重复元素，而且进行交集以及并集的运算

表示：{}

和dict之间的关系：set中只是存储了key

本质：无序且无重复元素的集合

#1.创建

#set()

#set()

s1={23,45,6,7,89}

print(s1)

print(type(s1))

#掌握：去除列表中的重复元素

s2=set([3,46,5,65,7,65,晏殊浣溪沙赏析 7])

print(s2)

s3=set((2,43,54,5,4,5))

print(s3)

s4=set({10:\"a\",20:\"b\"})

print(s4)

#是可变的

#2.1添加

#add(),添加，

set1={11,22,33,44,55}

#单个元素

(66)

print(set1)

#如果元素存在，则添加失败，不报错

(55)

#多个元素

#([77,88])#TypeError:unhashabletype:\'list\'

((77,88))

#({1:\"a\"})

#结论：在set中，使用add添加，则只能添加元组，不能添加list和dict

print(s1)

#update()，更新,update的参数只能是可迭代对象【打碎加入】

set2={11,22,33,44,55}

#(66)#报错：TypeError:\'int\'objectisnotiterable

([66])

print(set2)

((77,88))

print(set2)

({\"12\":12,\"13\":13})

print(set2)

(\"hgjhg\")

print(set2)

#3.删除

(77)

print(set2)

#4.交集和并集

s1={3,54,4,5,7}

s2={3,54,4,8,90}

#交集：&【按位与】

print(s1&s2)

#并集：|【按位或】

print(s1|s2)

list、tuple、dict、set的区别和联系：

a、定义方式：list：[]、tuple：（）、dict：{}、set：{}

b、是否有序：list:有序，tuple：有序，dict：无序，set：无序

c、是否允许出现重复元素：list：允许，tuple：允许，dict：key键值不允许，但是value的值允许，set：不允许

d、都属于可迭代对象

e、set相当于存储了字典中的key

f、可以向互转化

4、附录

4.1字符串转义字符表

在需要在字符中使用特殊字符时，python用反斜杠()转义字符击筑饮美酒下一句是什么 。如下表：

转义字符描述

(在行尾时)续行符

反斜杠符号

\'单引号

\"双引号

a响铃

b退格(Backspace)

e转义

000空

n换行

v纵向制表符

t横向制表符

r回车

f换页

oyy八进制数，yy代表的字符，例如：o12代表换行

yy十六进制数，yy代表的字符，例如：0a代表换行

other其它的字符以普通格式输出

4.2python字符串格式化符号表

符号描述

%c格式化字符及其ASCII码

%s格式化字符串

%d格式化整数

%u格式化无符号整型

%o格式化无符号八进制数

%x格式化无符号十六进制数

%X格式化无符号十六进制数（大写）

%f格式化浮点数字，可指定小数点后的精度

%e用科学计数法格式化浮点数

%E作用同%e，用科学计数法格式化浮点数

%g%f和%e的简写

%G%f和%E的简写

%p用十六进制数格式化变量的地址

4.3格式化操作符辅助指令表

符号功能

*定义宽度或者小数点精度

-用做左对齐

+在正数前面显示加号(+)

在正数前面显示空格

#在八进制数前面显示零(\'0\')，在十六进制前面显示\'0x\'或者\'0X\'(取决于用的是\'x\'还是\'X\')

0显示的数字前面填充\'0\'而不是默认的空格

%\'%%\'输出一个单一的\'%\'

(var)映射变量(字典参数)

4.4字符串内建方法表

序号方法描述

1capitalize()将字符串的第一个字符转换为大写

2center(width,fillchar)返回一个指定的宽度width居中的字符串，fillchar为填充的字符，默认为空格。

3count(str,beg=0,end=len(string))返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数

**(encoding=\"utf-8\",errors=\"strict\")Python3中没有decode方法，但我们可以使用bytes对象的decode()方法来解码给定的bytes对象，这个bytes对象可以由()来编码返回。

**5encode(encoding=\'UTF-8\',errors=\'strict\')以encoding指定的编码格式编码字符串，如果出错默认报一个ValueError的异常，除非errors指定的是\'ignore\'或者\'replace\'

**6endswith(suffix,beg=0,end=len(string))检查字符串是否以obj结束，如果beg或者end指定则检查指定的范围内是否以obj结束，如果是，返回True,否则返回False.

7expandtabs(tabsize=8)把字符串string中的tab符号转为空格，tab符号默认的空格数是8。

**8find(str,beg=0end=len(string))检测str是否包含在字符串中，如果指定范围beg和end，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

9index(str,beg=0,end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常.

10isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False

11isalpha()如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False

12isdigit()如果字符串只包含数字则返回True否则返回False..

13islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False

14isnumeric()如果字符串中只包含数字字符，则返回True，否则返回False

15isspace()如果字符串中只包含空白，则返回True，否则返回False.

16istitle()如果字符串是标题化的(见title())则返回True，否则返回False

17isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False饼的拼音

**18join(seq)以指定字符串作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串

*19len(string)返回字符串长度

20ljust(width[,fillchar])返回一个原字符串左对齐,并使用fillchar填充至长度width的新字符串，fillchar默认为空格。

21lower()转换字符串中所有大写字符为小写.

22lstrip()截掉字符串左边的空格或指定字符。

**23maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

*24max(str)返回字符串str中最大的字母。

*25min(str)返回字符串str中最小的字母。

**26replace(old,new[,max])把将字符串中的str1替换成str2,如果max指定，则替换不超过max次。

27rfind(str,beg=0,end=len(string))类似于find()函数，不过是从右边开始查找.

28rindex(str,beg=0,end=len(string))类似于index()，不过是从右边开始.

29rjust(width,[,fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度width的新字符串

30rstrip()删除字符串字符串末尾的空格.

**31split(str=\"\",num=(str))num=(str))以str为分隔符截取字符串，如果num有指定值，则仅截取num个子字符串

**32splitlines([keepends])按照行(\'r\',\'rn\',n\')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符。

**33startswith(str,beg=0,end=len(string))检查字符串是否是以obj开头，是则返回True，否则返回False。如果beg和end指定值，则在指定范围内检查。

**34strip([chars])在字符串上执行lstrip()和rstrip()

35swapcase()将字符串中大写转换为小写，小写转换为大写

36title()返回\"标题化\"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见istitle())

**37translate(table,deletechars=\"\")根据str给出的表(包含256个字符)转换string的字符,要过滤掉的字符放到deletechars参数中

38upper()转换字符串中的小写字母为大写

39zfill(width)返回长度为width的字符串，原字符串右对齐，前面填充0

40isdecimal()检查字符串是否只包含十进制字符，如果是返回true，否则返回false。

备注：*标记为相关内建函数，**标记为常用方法。

4.5Python列表函数&方法

Python包含以下函数:

序号函数描述

1[len(list)列表元素个数

2[max(list)返回列表元素最大值

3[min(list)返回列表元素最小值

4[list(seq)将元组转换为列表

Python包含以下方法:

序号方法描述

(obj)在列表末尾添加新的对象

(obj)统计某个元素在列表中出现的次数

(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

(obj)从列表中找出某个值第一个匹配项的索引位置

(index,obj)将对象插入列表

([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

(obj)移除列表中某个值的第一个匹配项

e()反向列表中元素

(cmp=None,key=None,reverse=False)对原列表进行排序

()清空列表

()复制列表

标签:Python