初识Python

IDLE是一个Python Shell,shell就是外壳的意思，是一个通过键入文本与程序交互的途径。

#将一个字符串乘以8，则连续输出8个这样的字符串。

>>> print("I love Python!\n"*8)

I love Python!

BIF==Built-in functions

#可以看到Python中的BIF,但并不全是

dir(_builtins_)

#查看某BIF的用法

help(input) help(int)

变量：其实就是社会上的一个名字，把一个值赋值给一个名字时，Ta会存储在内存中，称之为变量(variable).

Python和大多数计算机语言做法稍有不同，Ta并不是把值存储在变量中，而更像是把名字贴在上面。（Python没有“变量”，只有“名字”）

#不需要为变量定义类型，Python会智能识别值的类型

>>> teacher='小鱼儿'

>>> print(teacher)

小鱼儿

>>> teacher='大鱼儿'

>>> print(teacher)

大鱼儿

>>> type(teacher)

#teacher的类型

字符串加字符串的语法称为拼接

>>> a='你好'

>>> b='Python!'

>>> c=a+b

>>> print(c)

你好Python!

变量使用前需要先进行赋值，负责会出现错误

>>> first #first未进行赋值

Traceback (most recent call last):

File "", line 1, in

first

NameError: name 'first' is not defined

变量的命名尽量要见文知意，与社会相联系

两个不同类型的值不能相加，否则会出现错误

>>> '5'+'8'

'58'

>>> '5'+8

Traceback (most recent call last):

File "", line 1, in

'5'+8

TypeError: Can't convert 'int' object to str implicitly

转义字符（\）对字符串的引号进行转义

>>> 'let\'s go!'

"let's go!"

在对多个反斜杠进行转义的过程中可以使用r，字符串的结尾不能加反斜杠，否则会报错，只能通过其他的方式解决。

>>> str=r'C:\now'

>>> str

'C:\\now'

三重双引号实现长字符串的换行操作

>>> str="""白日依山尽，

黄河入海流。

欲穷千里目，

更上一层楼。

"""

>>> str

'白日依山尽，\n黄河入海流。\n欲穷千里目，\n更上一层楼。\n'

>>> print(str)

白日依山尽，

黄河入海流。

欲穷千里目，

更上一层楼。

Python判断机制

>>> 1<3

True

>>> 1>3

False

>>> 1!=1

False

>>> 1==1

True

条件分支语法：

if条件：

条件为真(True)执行操作 #Python通过空格或制表符来控制代码块

else:

条件为假(False)执行操作

while循环语法：

while条件：

条件为真(True)执行操作

random模块

>>> import random

>>> ta=random.randint(1,10)

>>> ta

数据类型：整型，浮点型，布尔类型，e记法

e记法

>>> 1.5e11

150000000000.0

布尔类型计算

>>> True+True

>>> True+False

>>> True*False

>>> True/False#被除数不能为0，否则报错

Traceback (most recent call last):

File "", line 1, in

True/False

ZeroDivisionError: division by zero

>>> False/True

0.0

类型转换：int(),str(),float()

关于类型信息：type(),isinstance()

>>> a='skd'

>>> isinstance(a,str)如果a的类型与传入的类型一致则返回True

True

>>> isinstance(a,int)

False

算术运算符：+，-，*，/，%，**(求幂)，//.

>>> 10//8

>>> 3.0//2

1.0

逻辑操作符：and,or,not

断言（assert）当关键字后面条件为假时，程序会自动崩溃并抛出AssertionError的异常。

>>> assert 3>4

Traceback (most recent call last):

File "", line 1, in

assert 3>4

AssertionError

>>> assert 3<4 #为真时，直接跳过

>>>

三元操作符：small=x if x

for循环体语法：

for目标 in 表达式：

循环体

>>> favourite='Fisher'

>>> for i in favourite:

print(i,end=' ')

F i s h e r

内置函数：range([start,]stop[,step=1])

这个BIF有三个参数，其中括号括起来的两个表示这两个参数是可选的。

step=1表示第三个参数的值默认值是1

range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列

>>> list(range(5))

[0, 1, 2, 3, 4]

>>> for each in range(5):

print(each)

>>> list(range(1,10))

[1, 2, 3, 4, 5, 6, 7, 8, 9]

两个关键字：break,continue

break:终止整个循环

for i in range(10):

if i%2!=0:

print(i)

continue

i+=2

print(i)

列表：整数，浮点数，字符串，对象。

定义

>>> member=['Python','语言','精通','使用']#在列表中可以存放任何种类型的数据

>>> member

['Python', '语言', '精通', '使用']

>>> number=[1,2,3,4,5]

>>> number

[1, 2, 3, 4, 5]

>>> mix=[1,'Python','图书馆',[3.14,5]]#也可以存放子列表

>>> mix

[1, 'Python', '图书馆', [3.14, 5]]

>>> empty=[]#创建一个空的列表

>>> empty

[]

向列表中添加数据

>>> member.append('标牌') #向member列表中添加数据

>>> member

['Python', '语言', '精通', '使用', '标牌']#所添加的数据默认放在列表的尾部

>>> len(member)#获取列表member的长度

append()方法不能同时把两个元素加入列表中，所以就引入了extend()方法

>>> member.extend('牡丹','菊花')#将一组元素以列表的形式加入列表

Traceback (most recent call last):

File "", line 1, in #否则会报错

member.extend('牡丹','菊花')

TypeError: extend() takes exactly one argument (2 given)

>>> member.extend(['牡丹','菊花'])

>>> member

['Python', '语言', '精通', '使用', '标牌', '牡丹', '菊花']#和append()同样是追加到列表的末尾

为了解决元素插入指定位置的问题，提出了insert()方法

>>> member.insert(1,'大家好')#把字符串插入位置为1的地方

>>> member

['Python', '大家好', '语言', '精通', '使用', '标牌', '牡丹', '菊花']

从列表中获取元素

>>> member[0]

'Python'

>>> member[1] #获取1位置的值

'大家好'

>>> temp=member[0]#交换位置0和1中元素的值

>>> member[0]=member[1]

>>> member[1]=temp

>>> member

['大家好', 'Python', '语言', '精通', '使用', '标牌', '牡丹', '菊花']

从列表中删除元素

>>> member.remove('大家好')#需要知道你要删除的元素的值，如果列表中不存在则会报错

>>> member

['Python', '语言', '精通', '使用', '标牌', '牡丹', '菊花']

>>> del member[2]#删除位置2中元素的值

>>> member

['Python', '语言', '使用', '标牌', '牡丹', '菊花']

>>>del member#删除整个列表，如果再次使用此列表，需要重新定义

Python的列表是利用栈的存储结构实现的，pop()可以弹出列表的尾部元素

>>> member.pop()

'菊花'

>>> member

['Python', '语言', '使用', '标牌', '牡丹']

>>> a=member.pop(1)#弹出1位置的值并赋值给a

>>> member

['Python', '使用', '标牌', '牡丹']

>>> a

'语言'

列表分片(Slice)

>>> member[1:3]#不包含3

['使用', '标牌']

>>> member[:3]

['Python', '使用', '标牌']

>>> member[1:]#包含1

['使用', '标牌', '牡丹']

>>> member[:]

['Python', '使用', '标牌', '牡丹']

操作符

比较操作符

逻辑操作符

连接操作符

重复操作符

成员关系操作符

比较操作符

>>> list1=[123]

>>> list2=[234]

>>> list1>list2

False

>>> list1=[123,456]

>>> list2=[234,123]

>>> list1>list2 #只比较了列表中的第一个元素

False

逻辑操作符

>>> (list1

True

连接操作符

>>> list4=list1+list2#列表的拼接操纵，限制为相同的类型

>>> list4

[123, 456, 234, 123]

>>> list3

[123, 456]

重复操作符

>>> list3*3#列表的扩展，但不会改变原列表

[123, 456, 123, 456, 123, 456]

>>> list3*=3#把列表进行扩展，并赋予原有的列表

>>> list3

[123, 456, 123, 456, 123, 456]

>>> list3*=5

>>> list3

[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]

成员关系操作符

>>> 123 in list3

True

>>> '小鱼儿'not in list3

True

>>> 123 not in list3

False

>>> list5=[123,['国花','牡丹'],456]

>>> '国花' in list5

False

>>> '国花' in list5[1]#人为的引入得以解决此类问题

True

>>> list5[1][1]

'牡丹'

列表的内置函数：

>>> list3

[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]

>>> list3.count(123)#获取列表中某值出现的次数

>>> list3.index(123)#获取列表中某值出现的第一个位置

>>> list3.index(123,3,7)#获取列表中123在第三到第七的位置中，第一次出现的位置

reverse()把整个列表原地翻转

>>> list5

[123, ['国花', '牡丹'], 456]

>>> list5.reverse()

>>> list5

[456, ['国花', '牡丹'], 123]

sort()方法对整个列表进行从小到大的排序

>>> list6=[9,6,7,5,11,36]

>>> list6.sort()

>>> list6

[5, 6, 7, 9, 11, 36]

>>> list6.sort(reverse=True)#借助reverse实现从大到小排序

>>> list6

[36, 11, 9, 7, 6, 5]

分片的优势在于脱离原有的列表的控制

>>> list6

[36, 11, 9, 7, 6, 5]

>>> list7=list6[:]

>>> list7

[36, 11, 9, 7, 6, 5]

>>> list8=list6

>>> list8

[36, 11, 9, 7, 6, 5]

>>> list6.sort()

>>> list6

[5, 6, 7, 9, 11, 36]

>>> list8

[5, 6, 7, 9, 11, 36]

>>> list7

[36, 11, 9, 7, 6, 5]

元组(带上枷锁的列表)tuple

元组和列表基本相似

元组是不能随意插入或者删除一个元素，元组是不可改变的

创建一个元组，元组的创建关键不在括号，而在逗号

>>> tuple1=(1,2,3,4,5,6,7,8)

>>> tuple1

(1, 2, 3, 4, 5, 6, 7, 8)

>>> temp=(1)

>>> temp

>>> type(temp)

>>> temp2=2,3,4

>>> type(temp2)

>>> temp=()#创建一个空的元组

>>> type(temp)

>>> temp=(1,)

>>> type(temp)

>>> temp=1,

>>> type(temp)

>>> 8*(8)

>>> 8*(8,)

(8, 8, 8, 8, 8, 8, 8, 8)

通过分片以及重新分配来实现元组的更新

>>> temp=('小鱼儿','黑夜','迷途','小布丁')

>>> temp=temp[:2]+('怡景',)+temp[2:]#添加部分中的逗号是不能缺少的

>>> temp

('小鱼儿', '黑夜', '怡景', '迷途', '小布丁')

>>>del temp#删除整个元组

也可以通过切片的方法间接的删除元组的元素

>>> temp

('小鱼儿', '黑夜', '怡景', '迷途', '小布丁')

>>> temp=temp[:2]+temp[3:]

>>> temp

('小鱼儿', '黑夜', '迷途', '小布丁')

元组的相关操作符，和列表是一样的

格式化

format()

字段0，1，2分别用花括号括起来，通过后面的位置参数传递给format()方法，然后再通过format()方法进行格式化整理，最后得到了最终的目标。

>>> "{0} love {1}.{2}".format("I","Fish","com")

'I love Fish.com'

使用关键字参数进行传递

>>> "{a} love {b}.{c}".format(a="I",b="Fish",c="com")

'I love Fish.com'

综合位置参数以及关键字参数的传递

>>> "{0} love {b}.{c}".format("I",b="Fish",c="com")

'I love Fish.com' #需要注意的是位置参数一定要在关键字参数之前，否则会报错

利用转义打印反斜杠

>>> print('\ta')#此处是缩进8格

>>> print('\\')

打印花括号

>>> "{{0}}".format("不打印")

'{0}'#和两个反斜杠是一样的道理，因为0被解释掉了，所以后面的值无法打印

0后面的冒号表示格式化符号的开始，后面就是格式化，此处打印的为定点数

>>> '{0:.1f}{1}'.format(26.658,'GB')

'26.7GB'

格式化字符及其ASCII码%c

>>> '%c'%97

'a'

>>> '%c % c %c'%(97,98,99)#其中的一串数字必须用括号括起来

'a b c'

格式化字符串%s

>>> '%s'%'I love fisher'

'I love fisher'

格式化整数

>>> '%d + %d = %d' % (4,5,4+5)

'4 + 5 = 9'

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

>>> '%o' % 10

'12'

格式化无符号十六进制%x，%X(大写用的)

>>> '%x' % 10

'a'

>>> '%X' % 10

'A'

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

%e用科学技术法格式化定点数

%g根据值的大小决定使用%f或%e

>>> '%f' % 27.658

'27.658000'

>>> '%e' % 27.658

'2.765800e+01'

>>> '%E' % 27.658

'2.765800E+01'

>>> '%g' % 27.658

'27.658'

格式化操作辅助命令

m.n m表示指定的宽度，n表示小说点后的位数。

‘-’用于左对齐，

‘+’在正数面前显示加号

‘#’在八进制前面显示‘0’，十六进制前面显示‘0x’或‘0X’

>>> '%5.1f' % 27.658

' 27.7'

>>> '%.2e' % 27.658

'2.77e+01'

>>> '%10d' % 5

' 5'

>>> '%-10d' % 5

'5 '

>>> '%+d' % 5

'+5'

>>> '%+d' % -5

'-5'

>>> '%#o' % 10

'0o12'

>>> '%#X' % 10

'0XA'

列表、元组和字符串的共同点

--都可以通过索引得到每一个元素

--默认索引值总是从0开始

--可以通过分片的方法得到一个范围内的元素的集合

--有很多共同的操作符（重复操作符，拼接操作符，成员关系操作符）

把这三者统称为序列

序列常见的内置方法(BIF)

list()把一个可迭代对象转换为列表

>>> a=list()

>>> a

[]

>>> b='My Python'

>>> b=list(b)

>>> b

['M', 'y', ' ', 'P', 'y', 't', 'h', 'o', 'n']

>>> c=(1,1,2,3,5,8,13,21)

>>> c=list(c)

>>> c

[1, 1, 2, 3, 5, 8, 13, 21]

tuple()把一个可迭代对象转换为元组

str(obj)把obj对象转换为字符串

max()返回序列或者参数集合中的最大值

>>> max(c)

>>> max(b)

'y'

>>> numbers

[1, 5, 8, -85, 14, 28, 'a']

>>> max(numbers)#两种不同类型的值无法进行比较

Traceback (most recent call last):

File "", line 1, in

max(numbers)

TypeError: unorderable types: str() > int()

min()返回序列或者参数集合中的最小值

sum(iterable[,start=0])返回序列iterable和可选参数start的总和

>>> sum(c)

>>> sum(c,10)

sorted()默认是从小到大排序

reversed()返回的是一个迭代器对象，可以通过list()方式实现输出

>>> reversed(c)

>>> list(reversed(c))

[21, 13, 8, 5, 3, 2, 1, 1]

enumerate()枚举方法

>>> enumerate(c)

>>> list(enumerate(c))

[(0, 1), (1, 1), (2, 2), (3, 3), (4, 5), (5, 8), (6, 13), (7, 21)]#在每个元素前加了一个索引值

zip()

>>> a=[1,2,3,4,5,6,7,8,9]

>>> b=[4,5,6,7,8]

>>> zip(a,b)

>>> list(zip(a,b))

[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]

函数

我的第一个Python函数：

>>> def MyFirstFunction():

print('这是我创建的第一个函数！')

print('我表示很激动！')

>>> MyFirstFunction()

这是我创建的第一个函数！

我表示很激动！

函数的参数的引用

>>> def MySecondFunction(name):

print(name + '我爱你！')

>>> MySecondFunction('Python')

Python我爱你！

一个简单的加法的函数

>>> def add(num1,num2):

result=num1+num2

print(result)

>>> add(2,6)

>>> def add(num1,num2):

return(num1+num2)#指定一个返回值

>>> print(add(4,5))#打印返回值

函数文档和注释不同

>>> def WordFunction(name):

‘函数定义过程中的name是叫形参' #函数文档方便其他人了解这个函数的定义

#因为Ta只是一个形式，表示占据一个参数位置 #此处为注释，不被编译

print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')

>>> WordFunction('黄河')

传递进来的黄河叫做实参，因为Ta是具体的参数值！

>>> help(WordFunction)

Help on function WordFunction in module __main__:

WordFunction(name)

函数定义过程中的name是叫形参

关键字参数：其实就是给参数下了一个定义

>>> def SaySome(name,words):

print(name + '-->' + words)

>>> SaySome('李宁','一切皆有可能！')

李宁-->一切皆有可能！

>>> SaySome('一切皆有可能！','李宁')

一切皆有可能！-->李宁

>>> SaySome(words='一切皆有可能！',name='李宁')

李宁-->一切皆有可能！

收集参数(也可称可变参数)

>>> def test(*params):#params为收集参数

print('参数的长度是：',len(params))

print('第二个参数是：',params[1])

>>> test(1,'黄河',3.14,5,6) #把参数打包为一个元组的形式

参数的长度是：5

第二个参数是：黄河

>>> def test(*params,exp):

print('参数的长度是：',len(params),exp)

print('第二个参数是：',params[1])

>>> test(1,'黄河',3.14,5,6) #exp需要通过关键字参数的形式来获取值

Traceback (most recent call last):

File "", line 1, in

test(1,'黄河',3.14,5,6)

TypeError: test() missing 1 required keyword-only argument: 'exp'

>>> test(1,'黄河',3.14,5,6,exp=8)

参数的长度是：5 8

第二个参数是：黄河

函数和过程：有返回值的为函数，没有返回值的为过程。

Python只有函数没有过程。

>>> def hello():

print('大家好！')

>>> temp=hello()

大家好！

>>> temp

>>> print(temp)#返回的是none

None

>>> type(temp)

Python是动态的确定类型，可以返回多个值

>>> def back():

return [1,'黄河',3.14]

>>> back()

[1, '黄河', 3.14]

>>> def back():

return 1,'黄河',3.14

>>> back()

(1, '黄河', 3.14)

变量：局部变量，全局变量。

1.在函数里定义的参数为局部变量，只能在函数内生效，脱离函数，便不存在了。

2.但是全局变量可以在函数中生效，所以对全局变量的使用需要十分注意

3.当试图在函数中修改全局变量的时候，它会在函数中自动创建一个和全局变量名字一样的局部变量，并赋予新值，退出函数后，全局变量的值不会有所变动。

>>> ================================ RESTART ================================

1.请输入原价：100

请输入折扣率：0.8

打折后的价格是：80.0#此处试图打印局部变量的值，出现错误

Traceback (most recent call last):

File "E:/Python/局部变量和全局变量.py", line 8, in

print('这里试图打印局部变量final_price的值：',final_price)

NameError: name 'final_price' is not defined

>>> ================================ RESTART ================================

>>>

2.请输入原价：100

请输入折扣率：0.6

这里试图打印全局变量old_price的值： 100.0#在函数中打印全局变量

打折后的价格是：60.0

>>> ================================ RESTART ================================

>>>

3.请输入原价：100

请输入折扣率：0.5

修改后old_price的值是1： 50#函数中自动创建和全局变量一样的局部变量

打折后的价格是：50.0

修改后old_price的值是2： 100.0#脱离函数后的全局变量

global关键字:通过global关键字可以将函数中的变量变为全局变量

>>> def MyFun():

global count

count=5

print(count)

>>> MyFun()

>>> count

内嵌函数：允许在函数中创建另一个函数，也可称为内部函数。

>>> def fun1():

print('fun1正在被调用...')

def fun2(): #此函数脱离外部函数，就无法使用

print('fun2正在被调用...')

fun2()

>>> fun1()

fun1正在被调用...

fun2正在被调用...

内部函数整个作用域都在外部函数之内的

闭包：如果在一个内部函数里，对外部作用域(但不是在全局作用域)的变量进行引用,则内部函数就会被认为是闭包。

>>> def FunX(x):

def FunY(y):

return x*y

return FunY

>>> i=FunX(5)

>>> type(i)

>>> i(5)

>>> FunX(5)(6)

在内部函数中使用关键字nolocal实现对局部变量的合法使用

>>> def fun1():

x=5

def fun2():

nonlocal x

x*=x

return x

print('此时函数中x的值为：',x)

return fun2()

>>> fun1()

此时函数中x的值为： 5#局部变量的值未发生改变

lambda表达式

一个参数的定义

>>> def ds(x):

return 2*x+1

>>> ds(5)

>>> g = lambda x : 2 * x + 1

>>> type(g)

>>> g(5)

两个参数的定义，x，y，作为参数，冒号后面的为返回值

>>> def add(x,y):

return x+y

>>> add(3,4)

>>> f=lambda x,y : x + y

>>> f(3,4)

两个比较厉害的BIF

过滤器filter(function or None,iterable)

第一个参数定义为None，则表示从可迭代的序列中获取非False的值

>>> filter(None,[1,0,False,True])

>>> list(filter(None,[1,0,False,True]))

[1, True]

定义一个返回奇数的函数，从列表中过滤出其中的奇数的元素

>>> def odd(x):

return x%2

>>> temp=range(10)

>>> show=filter(odd,temp)

>>> list(show)

[1, 3, 5, 7, 9]

通过lambda表达式来实现以上的函数

>>> list(filter(lambda x:x%2,range(10)))

[1, 3, 5, 7, 9]

map(function,iterable)把可迭代序列的每个元素作为参数，通过function进行加工，都加工完毕后，返回新的序列。

>>> list(map(lambda x: x*2,range(10)))

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

字典

它是两个元素之间的映射类型。

通过列表实现这种映射关系，但是明显不方便

字典由多个键和相对应的值所组成

>>> brand=['李宁','耐克','阿迪达斯']

>>> slogan=['一切皆有可能','Just do it','Impossible is noting']

>>> print('李宁的口号是：',slogan[brand.index('李宁')])

李宁的口号是：一切皆有可能

字典由多个键和相对应的值所组成，键值组合称为项

>>> dict1={'李宁':'一切皆有可能','耐克':'Just do it','阿迪达斯':'Impossible is noting'}

>>> print('李宁的口号是：',dict1['李宁'])

李宁的口号是：一切皆有可能

>>> dict2={1:'one',2:'two',3:'three'}

>>> dict2[2]

'two'

>>> dict3={}#创建一个空的字典

>>> dict3

{}

通过映射类型和关键字实现字典的创建

>>> dict3=dict((('F',70),('i',105),('s',115),('h',104),('C',67)))

>>> dict3

{'i': 105, 'C': 67, 's': 115, 'F': 70, 'h': 104}

>>> dict4=dict(李宁='一切皆有可能',耐克='Just do it')

>>> dict4

{'李宁': '一切皆有可能', '耐克': 'Just do it'}

对字典进行添加和修改的操作

>>> dict4['爱迪生']='天才就是99%的汗水+1%灵感，但这1%的灵感远远比99%的汗水更重要’

>>> dict4

{'李宁': '一切皆有可能', '耐克': 'Just do it', '爱迪生': '天才就是99%的汗水+1%灵感，但这1%的灵感远远比99%的汗水更重要'}

>>> dict4['李宁']='让一切成为不可能'

>>> dict4

{'李宁': '让一切成为不可能', '耐克': 'Just do it', '爱迪生': '天才就是99%的汗水+1%灵感，但这1%的灵感远远比99%的汗水更重要'}

字典的内置函数：

dict.fromkeys(S[,v])

>>> dict1={}

>>> dict1.fromkeys((1,2,3))

{1: None, 2: None, 3: None}

>>> dict1.fromkeys((1,2,3),('one','two','three'))

{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}#并不如想象的那样

>>> dict1.fromkeys((1,3),'数字')

{1: '数字', 3: '数字'}#是重新生成一个字典，而不是在原有基础上的修改

获取字典的键

>>> for eachKey in dict1.keys():

print(eachKey)

获取字典的值

>>> for eachValue in dict1.values():

print(eachValue)

获取字典的所有项

>>> for eachItem in dict1.items():

print(eachItem)

当试图访问字典中不存在的键时则会报错

当然可以通过get来设置一个返回值作为提示

也可以通过成员操作符进行判断

>>> dict1.get(30)

>>> print(dict1.get(30))

None

>>> dict1.get(30,'木有！')

'木有！'

>>> 30 in dict1

False

>>> 29 in dict1

True

清空字典可以用clear()方法

>>> dict1.clear()

>>> dict1

{}

拷贝copy(),显然a的地址和c的地址一样，而b的地址是不同于a的

>>> a={1:'one',2:'two',3:'three'}

>>> b=a.copy()

>>> c=a

>>> b

{1: 'one', 2: 'two', 3: 'three'}

>>> c

{1: 'one', 2: 'two', 3: 'three'}

>>> id(a)

49261384

>>> id(b)

3138584

>>> id(c)

49261384

pop()方法和popitem()方法，弹出的部分将从字典里面剔除

>>> b

{1: 'one', 2: 'two', 3: 'three'}

>>> b.pop(2)

'two'#弹出的是一个键以及其对应的值

>>> b.popitem()#随机弹出来一个项

(1, 'one')

setdefault()方法不用于get()方法的是当字典中不存在这个项时，它会在字典中随机的位置添加一个这样的项

>>> b

{3: 'three'}

>>> b.setdefaule('小白')

>>> b

{3: 'three', '小白': None}

>>> b.setdefault(5,'five')

'five'

>>> b

{3: 'three', '小白': None, 5: 'five'}

update()方法可以用来更新另一个字典

>>> a

{'小白': None}

>>> b={'小白':'狗'}

>>> a.update(b)

>>> a

{'小白': '狗'}

>>> a

{'小白': '狗'}

>>> b={'小灰':'狼'}

>>> a.update(b)

>>> a

{'小灰': '狼', '小白': '狗'}

python学习笔记1

初识Python

操作符

你可能感兴趣的:(python学习笔记1)