03-Python基础-Day01

一：Hello World程序

　1、在linux 下创建一个文件叫hello.py,并输入    　

print("Hello World!")

　2、然后执行命令:python hello.py ,输出

localhost:~ jieli$ vim hello.py
localhost:~ jieli$ python hello.py
Hello World!

指定解释器

上一步中执行 python hello.py 时，明确的指出 hello.py 脚本由 python 解释器来执行。

如果想要类似于执行shell脚本一样执行python脚本，例： ./hello.py ，那么就需要在 hello.py 文件的头部指定解释器，如下：

#!/usr/bin/env python
  
print "hello,world"

如此一来，执行： ./hello.py 即可。

ps：执行前需给予 hello.py 执行权限，chmod 755 hello.py

在交互器中执行　

除了把程序写在文件里，还可以直接调用python自带的交互器运行代码

localhost:~ jieli$ python
Python 2.7.10 (default, Oct 23 2015, 18:05:06)
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello World!")
Hello World!

 Python注释

1、单行注释：#被注释的内容

2、多行注释：“”“被注释的内容”“”

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

---

字符串(String)

• python中单引号和双引号使用完全相同。
• 使用三引号('''或""")可以指定一个多行字符串。
• 转义符 '\'
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""

#!/usr/bin/python3
 
str='Runoob'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

Print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

#!/usr/bin/python3
 
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

import 与 from...import

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

导入sys模块

import sys
print('命令行参数为：')
for i in sys.argv:
    print(i)
print('\n Python 路径为：',sys.path)

导入sys模块的argv,path 成员

from sys import argv,path  #  导入特定的成员2 print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

二：用户输入

#用户输入
name = input("what is your name ?")
print("Please" + name)

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型

在 Python3.x 中 raw_input( ) 和 input( ) 进行了整合，去除了 raw_input( )，仅保留了 input( ) 函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

输入密码时，如果想要不可见，需要利用getpass 模块中的 getpass方法，即：

import getpass
pwd = getpass.getpass()   #在PyCharm中，运行该命令是无效的会卡在那。需要在terminal中运行。
print(pwd)

getpass模块=密码输入工具，提供了两个函数

1、getpass.getpass() #提示用户输入一个密码且不会回显

2、getpass.getuser() #返回用户的“登录名称”。此函数会按顺序检查环境变量 LOGNAME, USER, LNAME 和 USERNAME，并返回其中第一个被设置为非空字符串的值。 如果均未设置，则在支持 pwd 模块的系统上将返回来自密码数据库的登录名，否则将引发一个异常

#获取当前登录的用户名
>>> usr = getpass.getuser()
>>> print (usr)
XXOXX
>>>

三：模块初识

Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，以后的课程中会深入讲解常用到的各种库，现在，我们先来象征性的学2个简单的os的system原理

os模块system原理

• system函数可以将字符串转化成命令在服务器上运行；其原理是每一条system函数执行时，其会创建一个子进程在系统上执行命令行，子进程的执行结果无法影响主进程；

• 上述原理会导致当需要执行多条命令行的时候可能得不到预期的结果； 

import os
os.system('cd /usr/local')
os.mkdir('test.txt)

• 上述程序运行后会发现txt文件并没有创建在/usr/local文件夹下，而是在当前的目录下；

使用system执行多条命令

import os

os.system('cd /usr/local && mkdir abc.txt')
# 或者
os.system('cd /usr/local ; mkdir  231.txt')

os模块system原理

Sys.argv[]是用来获取命令行参数的，sys.argv[0]表示代码本身文件路径，所以参数从1开始

#test.py
import sys
a = sys.argv[0]
print(a)      

 得到的结果是test.py，这就是0指代码（即此.py程序）本身的意思

将代码中0改为1 :

  a=sys.argv[1]

保存后，再从控制台窗口运行，这次我们加上一个参数，输入：test.py what

 得到的结果就是我们输入的参数what，看到这里你是不是开始明白了呢。

四：.pyc是什么？

 

 当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。

所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式

五：字符串、列表、元组、字典操作

1、字符串常用方法

 　　字符串属于不可变数据类型，也就是说python创建一个字符串后，你不能把这个字符串的某一部分改变，任何上面的函数改变了字符串后，都会返回一个新的字符串，源字符串并没有改变

如下（1）

>>> name = 'Hello world abc'
>>> name_1 = name.replace('abc','ABC')
>>> name
'Hello world abc'
>>> name_1
'Hello world ABC'

• 字符替换

　　　　替换str.replace(str1,str2,num) 用str2替换掉str1 num是次数，默认从左往右

>>> str_1 = 'Who are you? Python'
>>> str_2 = str_1.replace('are','Are',1).replace('you','You')
>>> print(str_2)
Who Are You? Python
>>> print(str_1)
Who are you? Python #    原字符串的值不变，字符串属于不可变数据类型

• 字符删除

str.strip(str1)删除字符串两边的指定字符，括号的写入指定字符，默认为空格

str.lstrip(str1)删除字符串左边的指定字符串

str.rstrip(str1)删除字符串右边指定字符串，默认空格

1 >>> str_01 = ' Welcome '
2 >>> str_02 = str_01.strip()
3 >>> print(str_02)
4 Welcome #　删除两边指定字符
>>> str_03 = str_01.rstrip()
>>> print(str_03)
 Welcome #　删除右边指定字符
>>> str_03 = str_01.lstrip()
>>> print(str_03)
Welcome  #　删除左边指定字符

• 字符截取

Python 截取字符串使用 变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾

格式： [start:end:step]

[:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串

1 >>> str = '012345'

2 >>> print (str[:])

012345 

 左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1

• 字符复制

>>> str1 = 'Neal'
>>> str2 = str1
>>> print(str2)
Neal

• 字符连接

>>> str3 = str1 + str2

>>> print(str3)

NealNeal 

• 字符比较

在python中，判断两个变量是否相等或一样，可以使用==或者is来判断；判断不一样可以使用 is not

>>> a = '01'
>>> b = '01'
>>> a==b
True
>>> a is b
True
>>> a is not b
False
>>> a != b
False
>>> a < b
False

• 字符查找

str.find(sub[, start[, end]])

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1

语法

find()方法语法：

str.find(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度

>>> user = 'administrator'
>>> print (user.find('a'))
0       # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
>>> print (user.find('a',1))
9       # 从下标1开始，查找在字符串里第一个出现的子串：返回结果9
>>> print (user.find('2'))
-1      # 查找不到返回结果-1

count 计数功能返回自定字符在字符串当中的个数

>>> mystr = 'administrator'
>>> print(mystr.count('a'))
2   #统计出a出现的次数

•  字符分割

split() 方法可以实现将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值反馈回来。该方法的基本语法格式如下

str.split(sep,maxsplit)[n] 

此方法中各部分参数的含义分别是：

1. str：表示要进行分割的字符串；
2. sep：用于指定分隔符，可以包含多个字符。此参数默认为 None，表示所有空字符，包括空格、换行符“\n”、制表符“\t”等。如果字符串中没有给定的分隔符时，则把整个字符串作为列表的一个元素返回
3. maxsplit：可选参数，用于指定分割的次数，最后列表中子串的个数最多为 maxsplit+1。如果不指定或者指定为 -1，则表示分割次数没有限制
4. [n]：表示选取第n个分片，n表示返回的list中元素下标，从0开始的

在 split 方法中，如果不指定 sep 参数，那么也不能指定 maxsplit 参数

>>> str = 'www.baidu.com'
>>> print (str.split())     #使用默认分隔符分割字符串
['www.baidu.com']
#指定分隔符为'.' 进行分割字符串 
>>> print (str.split('.'))
['www', 'baidu', 'com']
#指定分隔符为'.'，并且指定切割次数为1次
>>> print (str.split('.',1))
['www', 'baidu.com']
#指定分隔符为'.'，并取序列下标为0的项
>>> print (str.split('.')[0])
www
>>>

join()方法用于将一个序列中的元素以指定的字符连成字符串

语法

str.join(seq)

参数说明:

str：分隔符，可以为空字符串。

seq：要连接的元素序列、字符串、元组、字典

>>> str = '_'
>>> seq = ['a','b','c']
>>> print(str.join(seq))
a_b_c

• 修改字符串的大小写

1 >>> name = 'neal pan'
2 >>> print(name.title())
3 Neal Pan
4 >>>   #title（）以首字母大写的方式显示每个单词
>>> print(name.upper())
NEAL PAN
>>>    #upper() 将字符串改为全部为大写
>>> print(name.lower())
neal pan
>>>    #lower() 将字符串改为全部为小写

• 字符串格式化

模板：格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值传递给模板，每个值对应一个格式符

>>> print("I'm %s. I'm %d year old" % ('Vamei', 99))
I'm Vamei. I'm 99 year old
>>>
"I'm %s. I'm %d year old" 为我们的模板。%s为第一个格式符，表示一个字符串。%d为第二个格式符，表示一个整数。('Vamei', 99)的两个元素'Vamei'和99为替换%s和%d的真实值。 
在模板和tuple之间，有一个%号分隔，它代表了格式化操作

整个"I'm %s. I'm %d year old" % ('Vamei', 99) 实际上构成一个字符串表达式。我们可以像一个正常的字符串那样，将它赋值给某个变量。比如:

 a = "I'm %s. I'm %d year old" % ('Vamei', 99) 2 print(a) 

2、列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符

>>> list_1 = ['Neal',1998,'Pan']
>>> list_2 = [1,2,3,4,5,6]
>>> print (list_1[0:3])
['Neal', 1998, 'Pan']
>>> print (list_2[1:-2])
[2, 3, 4]

• 更新列表

list_1 = ['Neal',1998,'Pan']
>>> print ('第二个元素为:',list_1[2])
第二个元素为: Pan
list_1[2] = 'Feng'
print ("更新后的第二个元素为 : ", list[2])
第二个元素为: Feng

• 删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例

>>> print ('原始列表：',list_1)
原始列表： ['Neal', 1998, 'Feng']
>>> del list_1 [2]
>>> print ('原始列表：',list_1)
原始列表： ['Neal', 1998]
>>>

• 添加列表元素

>>> list = ["admin","guest","xxoxx"]
>>> list.append("account")
>>> print(list)
['admin', 'guest', 'xxoxx', 'account', 'account']
    #append()方法在列表中添加元素

• 在列表中插入元素

>>> list = ["admin","guest","xxoxx" 'account', 'account]
>>> list.insert(0,"defaul")
>>> print(list)
['defaul', 'admin', 'guest', 'xxoxx', 'account', 'account']
    #insert()方法在列表中插入元素

• 删除列表中任何位置元素

>>>list = ['defaul', 'admin', 'guest', 'xxoxx', 'account']
>>> pop_list = list.pop()
>>> print(pop_list)
account
>>> pop_list = list.pop(0)
>>> print(pop_list)
defaul
>>>
    #pop()删除列表中任意位置元素

•  根据列表元素名称定位位置

names = ["Zhangsan","lisi","wangwu"]
print(names.index("lisi"))
print(names[names.index("lisi")]) #index 根据列表元素确定位置
1
lisi

• 统计列表重复元素

names = ["Zhangsan","lisi","lisi","wangwu"]
print(names.count("lisi"))
输出结果
2

•  列表浅拷贝以及深拷贝

>>> names = ["zhangsan","lisi","wangwu","jack","Neal"]
>>> print(names[0],names[2])
zhangsan wangwu
>>>    ##打印第一个以及第三个元素
#切片操作
>>> print(names[0:-1:2])
['zhangsan', 'wangwu']
>>> #隔一个元素打印
#合并一个列表的内容
>>> name2 = [1,3,5,7,9]
>>> names.extend(name2)
>>> print(names)
['zhangsan', 'lisi', 'wangwu', 'jack', 'Neal', 1, 3, 5, 7, 9]
>>>

#copy浅拷贝与深拷贝
names = ["4ZhangYang", "#!Guyun","xXiangPeng",["alex","jack"],"ChenRonghua","XuLiangchen"]
name2 = names.copy() #相当于copy.copy(names)或者name2 = name[:] 或者 names2 = list(names)
print(names)
print(name2)
names[2] = "向鹏"
names[3][0] ="ALEXANDER"
print(names)
print(name2)
>>>
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['alex', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['alex', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', '向鹏', ['ALEXANDER', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['ALEXANDER', 'jack'], 'ChenRonghua', 'XuLiangchen'] ##注意向鹏这一项，names2没有跟着改，而alex这一项全改了
.copy()只能进行浅拷贝，复制到第一层，当列表当中还存在列表，就只会直接引用被复制元素的列表地址

• 深拷贝

import copy
names = ["4ZhangYang", "#!Guyun","xXiangPeng",["alex","jack"],"ChenRonghua","XuLiangchen"]
name2 = copy.deepcopy(names) #深拷贝
print(names)
print(name2)
names[2] = "向鹏"
names[3][0] ="ALEXANDER"
print(names)
print(name2)
>>>>>>
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['alex', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['alex', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', '向鹏', ['ALEXANDER', 'jack'], 'ChenRonghua', 'XuLiangchen']
['4ZhangYang', '#!Guyun', 'xXiangPeng', ['alex', 'jack'], 'ChenRonghua', 'XuLiangchen']

• 列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表 

• 列表截取与拼接

L=['Google', 'Runoob', 'Taobao']

拼接操作

>>> list_1 = [1,3,4,7,9]

>>> list_1 += [2,5,6,8]

>>> list_1

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

• 嵌套列表

使用嵌套列表即在列表里创建其它列表，例如

>>> a = ['a','b']
>>> n = [1,3,6]
>>> x = [a,n]
>>> x
[['a', 'b'], [1, 3, 6]]
>>> x[0]
['a', 'b']
>>> x[0][1]
'b'
>>>

• 列表循环

1 #for 循环内部使用变量 in 列表
2 name_list = ["zhangsan","lisi","wangwu"]
3 for name in name_list:
4     # 循环内部针对列表元素进行操作
5     print(name)

3、元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)

元组和列表之间的转换

使用 list 函数 可以把 元组 转换成 列表

使用 tuple 函数 可以把 列表 转换成 元组

list(元组)

>>> a = ['a','b']
>>> n = [1,3,6]
>>> x = [a,n]
>>> print (type(x))
<class 'list'>
>>> new_x = tuple(x)
>>> print(type(new_x))
<class 'tuple'>
#列表转换元组
>>> num = (1,3,6,9)
>>> print (type(num))
<class 'tuple'>
>>> list_num = list(num)
>>> print (type(list_num))
<class 'list'>
#元组转换列表

4、字典

 字典是一系列键-值对。每个键都与一个值相关联，你可以使用键来访问与之相关的值。与键值相关的值可以是数字，字符串，列表或字典等

字典用放在花括号{}中的一系列键-值对表示

Python有两种方法可以创建字典,第一种是使用花括号,另一种是使用内建 函数dict

>>> info = {}
>>> info = dict()

Python可以在创建字典的时候初始化字典

>>> info = {"name" : 'cold'}
>>> info = dict(name = 'cold')       # 更优雅
>>> print(info)
{'name': 'cold'}

很明显第二种方法更加的优雅和减少一些特殊字符的输入,但是有种情况第二种不能胜任

>>> key = 'name'
>>> info = { key :'cold'}  # {'name':'cold'}
>>> info = dict(key = 'cold') # {'key': 'cold'}

明显第二种方法就会引发一个不容易找到的bug

使用元组作为字典的Key

>>> dict2 = {(20, 30):'good', 30:'bad'}
>>> print(dict2)
{(20, 30): 'good', 30: 'bad'}
#创建的字典中第一个 key 是元组，第二个 key 是整数值，这都是合法的
需要指出的是，元组可以作为 dict 的 key，但列表不能作为元组的 key。这是由于 dict 要求 key 必须是不可变类型，但列表是可变类型，因此列表不能作为元组的 key

在使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。例如如下代码：

>>> vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
>>> dict3 = dict(vegetables)
>>> print(dict3)
{'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19}
## 创建包含3组key-value对的字典
>>> cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
>>> dict4 = dict(cars)
>>> print(dict4)
{'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>>
# 创建包含3组key-value对的字典

• 创建字典

 >>> aline_0 = {'color': 'green','points': 5}
 >>> print(aline_0['color'])
green
#通过Key访问Value
>>> aline_0 = {'color': 'green','points': 5}
>>> print(aline_0['points'])
5
>>>
#如果要为 dict 添加 key-value 对，只需为不存在的 key 赋值即可
scores = {'语文':89}
scores['数学'] = 93
scores['英语'] = 87
print(scores)
{'语文': 89, '数学': 93, '英语': 87}

如果要判断字典是否包含指定的 key，则可以使用 in 或 not in 运算符。需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。例如如下代码：

>>> aline_0 = {'color': 'green','points': 5}
>>> print('red' in aline_0)
False
#判断aline_0是否包含名为'red'的key
>>> print('red' not in aline_0)
True
>>>

通过上面介绍可以看出，字典的 key 是它的关键。换个角度来看，字典的 key 就相当于它的索引，只不过这些索引不一定是整数类型，字典的 key 可以是任意不可变类型。

可以这样说，字典相当于索引是任意不可变类型的列表：而列表则相当于 key 只能是整数的字典。因此，如果程序中要使用的字典的 key 都是整数类型，则可考虑能否换成列表。

此外，还有一点需要指出，列表的索引总是从 0 开始、连续增大的；但字典的索引即使是整数类型，也不需要从 0 开始，而且不需要连续。因此，列表不允许对不存在的索引赋值：但字典则允许直接对不存在的 key 赋值，这样就会为字典增加一个 key-value 对

• 添加键-值对

>>> aline_0 = {'color': 'green','points': 5}
>>> aline_0['x_position'] = 0
>>> aline_0['y_position'] = 23
>>> print(aline_0)
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 23}
>>>

• 修改字典中的值

>>> aline_0 = {'color': 'green','points': 5}
>>> aline_0['color'] = 'yellow'
>>> print(aline_0)
{'color': 'yellow', 'points': 5}
>>>

• 删除键-值对

>>> aline_0 = {'color': 'green','points': 5}
>>> del aline_0['color']
>>> print(aline_0)
{'points': 5}
>>>

字典常用方法

字典由 dict 类代表，因此我们同样可使用 dir(dict) 来查看该类包含哪些方法。在交互式解释器中输入 dir(dict) 命令，将看到如下输出结果

>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

clear()方法 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。例如如下代码：

>>> aline_0 = {'color': 'green','points': 5}
>>> print(aline_0)
{'color': 'green', 'points': 5}
>>> aline_0.clear()
>>> print(aline_0)
{}

get()方法

get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。例如如下代码

>>> aline_0 = {'color': 'green','points': 5}
>>> print(aline_0.get('color'))
green
>>> print(aline_0.get('red'))
None

update()方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去

例如如下代码

>>> aline_0 = {'color': 'green','points': 5}
>>> aline_0.update({'color': 'red','name': 'zhangsan'})
>>> print(aline_0)
{'color': 'red', 'points': 5, 'name': 'zhangsan'}
>>>

items()、keys()、values()

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表。如下代码示范了这三个方法的用法：

aline_0 = {'color': 'red','points': 5,'name': 'zhangsan'}
>>> print(aline_0)
{'color': 'red', 'points': 5, 'name': 'zhangsan'}
>>> ims = aline_0.items()
>>> print(type(ims))
# 获取字典所有的key-value对，返回一个dict_items对象
<class 'dict_items'>
>>> print(list(ims))
# 将dict_items转换成列表
[('color', 'red'), ('points', 5), ('name', 'zhangsan')]
>>>
# 访问第2个key-value对
>>> print(list(ims)[1])
('points', 5)
>>>

从上面代码可以看出，程序调用字典的 items()、keys()、values() 方法之后，都需要调用 list() 函数将它们转换为列表，这样即可把这三个方法的返回值转换为列表

 获取Key,value并循环

info = dict(name='百度',blog = 'baidu.com')
for key,value in info.items():
    print(key,':',value)
>>>>
name : 百度
blog : baidu.com

• popitem()方法

popitem() 方法用于随机弹出字典中的一个 key-value 对

此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素，实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对

>>> cars = {'语文': 80,'数学': 90,'英语': 86}
>>> print(cars)
{'语文': 80, '数学': 90, '英语': 86}
>>> print(cars.popitem()) # 弹出字典底层存储的最后一个key-value对
('英语', 86)
>>> print(cars)
{'语文': 80, '数学': 90}
>>>
由于实际上 popitem 弹出的就是一个元组，因此程序完全可以通过序列解包的方式用两个变量分别接收 key 和 value。例如如下代码：
>>> k,v = cars.popitem()
>>> print(k,v)
数学 90
>>>

使用词典传入真是值

temp = "语文:%(name_1)d, 数学:%(name_2)d, 出版社是:%(name_3)d"
book = {'name_1':80, 'name_2': 99, 'name_3': 88}
print(temp % book)
>>>>>
语文:80, 数学:99, 出版社是:88
# 使用字典为字符串模板中的key传入值

六、数据运算
算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python 支持所有基本算术运算符

 + 加法运算

a = 10
b = 20
sum = a + b
x = 2.5
y = 7.12
sum2 = x + y
print("sum=%d,sum2=%.2f" % (sum,sum2))
>>>
sum=30,sum2=9.62

- 减法运算符

>>> n  = 45
>>> m = -n
>>> x = -34
>>> y = -x
>>> print(m,";",y)
-45 ; 34
>>>

*乘法运算符

>>> n = 2*3
>>> f = 2.2*3
>>> print(n ,";",f)
6 ; 6.6000000000000005
>>>

/和//除法运算符

Python 支持/和//两个除法运算符，但它们之间是有区别的：

• /表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
• //表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。

>>> print("25/5=",25/5)
25/5= 5.0
>>>
>>> print("23/5=",23/5)
23/5= 4.6
>>> print("23//5=",23//5)
23//5= 4
>>>

从运行结果可以发现：

• /的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
• 当有小数参与运算时，//结果才是小数，否则就是整数。

%求余运算符

>>> print("15%-6=",15%-6)
15%-6= -3
>>> print("-15%6=",-15%6)
-15%6= 3
>>> print("15.5%6=",15.5%6)
15.5%6= 3.5
>>>
#从运行结果可以发现两点：
只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
%两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数

**次方（乘方）运算符

 ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算

>>> print("3**4=",3**4)
3**4= 81
# 次方运算

>>> print("2**(1/2)=",2**(1/2))
2**(1/2)= 1.4142135623730951
>>>
# 开方运算

2、比较运算

== 和 is 的区别

初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。

== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象，例如

import time
t1 = time.gmtime()
t2 = time.gmtime()
print(t1==t2)
print(t1 is t2)
>>>>
True
False

time 模块的 gmtime() 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。

虽然 t1 和 t2 的值相等，但它们是两个不同的对象（每次调用 gmtime() 都返回不同的对象），所以t1 is t2返回 False。这就好像两个双胞胎姐妹，虽然她们的外貌是一样的，但它们是两个人。

那么，如何判断两个对象是否相同呢？答案是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了；这就像两个名字使用了同一个身体，当然就是同一个人了

3、赋值运算

n1 = 100
f1 = 25.5
n1 -= 80  #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)
>>>>>
运行结果为：
n1=20
f1=255.00

通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。

但是请注意，这种赋值运算符只能针对已经存在的变量赋值，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：

n += 10

该表达式等价于 n = n + 10，n 没有提前定义，所以它不能参与加法运算

4、逻辑运算符

逻辑运算符一般和关系运算符结合使用，例如：

14>6 and 45.6 < 90

14>6 结果为 True，成立，45.6<90 结果为 False，不成立，所以整个表达式的结果为 False，也即不成立

age = int(input('请输入你的年龄：'))
height = int(input('请输入你的身高：'))
if age>=18 and age<=30 and height >=170 and height <=185:
    print("恭喜你，符合报考飞行员的条件")
else:
    print("抱歉，你不符合")

运行结果
请输入年龄：23↙
请输入身高：178↙
恭喜，你符合报考飞行员的条件

Python 逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。请看下面的例子

>>> print(100 and 200)
200
>>> print("" or "Neal")
Neal

逻辑运算符的本质

在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。

另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。

以上两点极其重要，了解这两点不会让你在使用逻辑运算的过程中产生疑惑

对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：

• 如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。
• 如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：

• 如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。
• 如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果

 

5、位运算符

 Python 位运算符只能用来操作整数类型，它按照整数在内存中的二进制形式进行计算

 

 1、首先了解以下二进制转换十进制

 

 2.第二种

　　00000001　　　　1

　　00000011　　　　3

　　00000111　　　　7

　　00001111　　　　15

　　00011111　　　　31

　　00111111　　　　63

　　01111111　　　　127

 

 

 举个例子：11101011

　　可分为：

　　　　　　11100000=224

　　　　　　00001000=8

　　　　　　00000011=3

需要记住2的0-10次方值

2^7　　2^6　　2^5　　2^4　　2^3　　2^2　　2^1　　2^0

128　　64　　32　　　16　　8　　　　4　　　2　　  1

+ 

============================================

0-7次方的总和为255

1、& 按位与运算符

按位与运算符&的运算规则是：只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似

 例如：9&5可以转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在内存中的存储）
-----------------------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001  （1 在内存中的存储）

&运算符会对参与运算的两个整数的所有二进制位进行&运算，9&5的结果为 1

又如，-9&5可以转换成如下的运算：

  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在内存中的存储）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在内存中的存储）
-----------------------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在内存中的存储）

-9&5的结果是 5

再强调一遍，&运算符操作的是数据在内存中存储的原始二进制位，而不是数据本身的二进制形式；其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111  0111  （-9 在内存中的存储）

-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （-9 的二进制形式，前面多余的0可以抹掉）

2、| 按位或运算符

按位或运算符|的运算规则是：两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为 1，0|0为0，1|0 为1，这和逻辑运算中的||非常类似

例如，9 | 5可以转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在内存中的存储）
-----------------------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101  （13 在内存中的存储）

9 | 5的结果为 13

3、^按位异或运算符

按位异或运算^的运算规则是：参与运算的两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为 1，0^0为 0，1^1为 0



例如，9 ^ 5可以转换成如下的运算：

  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在内存中的存储）
-----------------------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100  （12 在内存中的存储）

9 ^ 5的结果为 12

4、~按位取反运算符

按位取反运算符~为单目运算符（只有一个操作数），右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似
例如，~9可以转换为如下的运算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
-----------------------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110  （-10 在内存中的存储）

所以~9的结果为 -10

5、左移运算符

Python 左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0
例如，9<<3可以转换为如下的运算：

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
-----------------------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000  （72 在内存中的存储）

所以9<<3的结果为 72

6、>>右移运算符

Python 右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1
例如，9>>3可以转换为如下的运算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在内存中的存储）
-----------------------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001  （1 在内存中的存储）

所以9>>3的结果为 1

七、三目运算符（三元运算符）

我们从一个具体的例子切入本节内容。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 if else 语句，例如：

1. if a>b:
2. max = a;
3. else:
4. max = b;

但是 Python 提供了一种更加简洁的写法，如下所示：

max = a if a>b else b

这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言，它没有引入? :这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。

使用 if else 实现三目运算符（条件运算符）的格式如下：

exp1 if contion else exp2

condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。

前面的语句max = a if a>b else b的含义是：

• 如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
• 如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max

三目运算符的嵌套

Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：

a if a>b else c if c>d else d

应该理解为：

a if a>b else ( c if c>d else d )

【实例】使用 Python 三目运算符判断两个数字的关系：

1. a = int( input("Input a: ") )
2. b = int( input("Input b: ") )
3. print("a大于b") if a>b else ( print("a小于b") if a<b else print("a等于b") )

可能的运行结果：

Input a: 45↙
Input b: 100↙
a小于b

该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print("a大于b")，否则将继续执行 else 后面的内容，也就是：

( print("a小于b") if a<b else print("a等于b") )

进入该表达式后，先判断 a<b 是否成立，如果 a<b 的结果为 True，将执行 print("a小于b")，否则执行 print("a等于b")。

八、Python 运算符优先级

Python 支持几十种运算符，被划分成将近二十个优先级，有的运算符优先级不同，有的运算符优先级相同

结果表1中的运算符优先级，我们尝试分析下面表达式的结果：

4+4<<2

+的优先级是 12，<<的优先级是 11，+的优先级高于<<，所以先执行 4+4，得到结果 8，再执行 8<<2，得到结果 32，这也是整个表达式的最终结果。

像这种不好确定优先级的表达式，我们可以给子表达式加上( )，也就是写成下面的样子：

(4+4) << 2

这样看起来就一目了然了，不容易引起误解。

当然，我们也可以使用( )改变程序的执行顺序，比如：

4+(4<<2)

则先执行 4<<2，得到结果 16，再执行 4+16，得到结果20。

虽然 Python 运算符存在优先级的关系，但我不推荐过度依赖运算符的优先级，这会导致程序的可读性降低。因此，我建议读者：

• 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，可以尝试把它拆分来书写。
• 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用( )来控制表达式的执行顺序

Python 运算符结核性

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。

例如对于表达式对于100 / 25 * 16，/和*的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/和*都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性

当一个表达式中出现多个运算符时，Python 会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符