Python语言入门基础理论学习笔记

文章目录
[隐藏]

了解Python

Python是一种面向对象、直译式电脑编程语言,也是一种功能强大的通用型语言,已经具有近二十年的发展历史,成熟且稳定。它包含了一组完善而且容易理解的标准库,能够轻松完成很多常见的任务。它的语法非常简捷和清晰,与其它大多数程序设计语言使用大括号不一样,它使用缩进来定义语句块。

Python支持命令式程序设计、面向对象程序设计、函数式编程、面向切面编程、泛型编程多种编程范式。与Scheme、Ruby、Perl、Tcl等动态语言一样,Python具备垃圾回收功能,能够自动管理存储器使用。它经常被当作脚本语言用于处理系统管理任务和网络程序编写,然而它也非常适合完成各种高级任务。Python虚拟机本身几乎可以在所有的作业系统中运行。使用一些诸如py2exe、PyPy、PyInstaller之类的工具可以将Python源代码转换成可以脱离Python解释器运行的程序。

Python基本概念

Python程序源文件

Linux下执行Python通常这样写:

#!/usr/bin/python
# Filename : helloworld.py
print 'Hello World'

python是区分大小写的,使用#作为注释符。python获取帮助信息使用help()函数,例如获取and帮助:print help('and'),在Linux下执行Python程序和shell类似。

常量

像8、1.233、9.15e-3这样的数,或者'This is a string'、"It's a string!"这样的字符串。被称作字面意义上的常量,因为它们具备字面的意义,因为不能改变它的值,所有这些都被称为字面意义上的常量。

数字

在Python中有4种类型的数:整数、长整数、浮点数和复数。

  • 8是一个整数的例子。
  • 长整数不过是大一些的整数。
  • 3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
  • (-5+4j)和(2.3-4.6j)是复数的例子。

字符串

字符串是字符的序列,就是一组单词。几乎每个python都要使用到字符串。字符串是不可变的,意味着一旦创造了一个字符串,就不能再改变它了。字符串可以按字面意义连接,例如:'hello' 'world',就会被python自动转为'hello world'

使用单引号(') 
用单引号指示字符串,就如同'Quote me on this'这样。所有的空白,即空格和制表符都照原样保留。

使用双引号(")
在双引号中的字符串与单引号中的字符串的使用完全相同,例如"What's your name?"

使用三引号(''' 或 """)
用三引号指示多行的字符串。可以自由使用单引号和双引号。

转义符(\)
例如:'What\'s your name?'注意如果在字符串中行末尾单独的反斜杠表示字符串在下一行继续,而不是开始一个新的行。

自然字符串
如果在某些不需要特别处理的字符串(如转义符),那需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如:r"111111\n2222222"

Unicode字符串
Unicode是书写国际文本的标准方法。Python处理Unicode文本需要在字符串前加上前缀u或U。例如:u"This is a Unicode string."

Python语句中有一些基本规则和特殊字符:

  • 井字号#表示之后的字符为Python的注释;
  • 换行符\n是标准的行与行的分隔符(一般是一句一行);
  • 反斜杠\是继续上一行的意思,一行写不完到下一行继续写;
  • 分号;是将两个句子连接在一行中(不建议使用,最好每个物理行写一个逻辑行);
  • 冒号:是将代码的头和体分开;
  • 语句(代码块)用缩进的方式体现。不同缩进深度分隔不用的代码块;
  • Python文件是以模块的形式组织。

标识符

变量就是一种标识符,标识符命名需要遵循:

  • 第一个字符必须是字母(大写或小写)或者一个下划线(_)
  • 其他部分可以由字母(大写或小写)、下划线(_)或数字(0-9)组成。
  • 标识符名称区分大小写

数据类型

变量可以处理不同类型的值,称为数据类型。Python 有多种内置数据类型。以下是比较重要的一些:

  • Booleans[布尔型] 或为 True[真] 或为 False[假]。
  • Numbers[数值型] 可以是 Integers[整数](1 和 2)、Floats[浮点数](1.1 和 1.2)、Fractions[分数](1/2 和 2/3);甚至是 Complex Number[复数]。
  • Strings[字符串型] 是 Unicode 字符序列,例如: 一份 HTML 文档。
  • Bytes[字节] 和 Byte Arrays[字节数组], 例如: 一份 JPEG 图像文件。
  • Lists[列表] 是值的有序序列。
  • Tuples[元组] 是有序而不可变的值序列。
  • Sets[集合] 是装满无序值的包裹。
  • Dictionaries[字典] 是键值对的无序包裹。

变量赋值

  • 变量无需事先声明。
  • 变量无需指定类型。
  • 不需要关心内存管理,变量名会被“回收”
  • del语句能够直接释放资源。

Python中的=号是赋值操作符:

aaa = -23
bbb = 'hello'
ccc = -2.21 * (5.1 ** 3)
ddd = 'hello' + 'world'
eee = [3.14e10, '3en el of end a', 3.333-2.222j]

Python语言中赋值并不是将一个值赋给一个变量,对象是通过引用传递的。在赋值时,不管这个对象是新建的还是存在的都是将该对象的引用(并不是值)赋值给变量。

x = 1
y = x = x + 1
print x,y

增量赋值

符号和算术操作符连接在一起,将计算结果重新赋值给左边的变量,这就是增量赋值。例如:

x  = x + 1  可以写成  x += 1

其他操作符:+=  -=  *=  /=  %=  **=  <<=  >>=  &=  ^=  |=

多重赋值

创建了一个值为1的整数对象,把该对象的同一个引用赋给x、y、z,就是将一个对象赋给了多个变量。

x = y = z = 1
print x,y,x
输出:
1 1 1

多元赋值

将多个对象赋给多个变量就是多元变量,等号两边的对象都是元组。

(x, y, z) = (1, 2, 'a string')
print x, y, z
输出:
1 2 a string

利用多元赋值可以实现Python中的变量交换

x, y = 1, 2
print x, y
输出:
1 2

x, y = y, x
print x, y
输出:
2 1

对象

Python把在程序中用到的任何东西都称为 对象。就每一个东西包括数、字符串甚至函数都是对象这一点来说,Python是极其完全地面向对象的

逻辑行与物理行

物理行是在编写程序时所看见的。逻辑行是Python看见的单个语句。Python希望每个物理行对应一个逻辑行 。如果要在一个物理行中使用多个逻辑行,需要使用分号(;)标注,分号表示一个逻辑行语句结束的标记。一般不使用分号,只在每个物理行写一句逻辑行。

在多个物理行中写一个逻辑行可以在物理行的末尾使用反斜杠(\),这种写法被称为明确的行连接。还有一种暗示的连接,不需要使用反斜杠。这种情况出现在逻辑行中使用了圆括号、方括号或波形括号的时候。这被称为暗示的行连接

缩进

行首的空白称为缩进。在逻辑行首的空白(空格和制表符)用来决定逻辑行的缩进层次,从而用来决定语句的分组。同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。错误的缩进会引发错误。

不能混合使用制表符和空格来缩进,因为这在跨越不同的平台的时候,无法正常工作。每个缩进层次使用单个制表符或2个/4个空格,选择这三种缩进风格之一。更加重要的是,选择一种风格,然后一贯地使用它,即只使用这一种风格。

运算符与表达式

大多数语句(逻辑行)都包含表达式,一个表达式的例子:2 + 6,加号(+)就是为运算符,2和6是操作数

[表]运算符与它们的用法:

运算符 名称 说明 例子
+ 两个对象相加 3 + 5得到8。'a' + 'b'得到'ab'。
- 得到负数或是一个数减去另一个数 -5.2得到一个负数。50 - 24得到26。
* 两个数相乘或是返回一个被重复若干次的字符串 2 * 3得到6。'la' * 3得到'lalala'。
** 返回x的y次幂 3 ** 4得到81(即3 * 3 * 3 * 3)
/ x除以y 4/3得到1(整数的除法得到整数结果)。4.0/3或4/3.0得到1.3333333333333333
// 取整除 返回商的整数部分 4 // 3.0得到1.0
% 取模 返回除法的余数 8%3得到2。-25.5%2.25得到1.5
<< 左移 把一个数的比特向左移一定数目(每个数在内存中都表示为比特或二进制数字,即0和1) 2 << 2得到8。——2按比特表示为10
>> 右移 把一个数的比特向右移一定数目 11 >> 1得到5。——11按比特表示为1011,向右移动1比特后得到101,即十进制的5。
& 按位与 数的按位与 5 & 3得到1。
| 按位或 数的按位或 5 | 3得到7。
^ 按位异或 数的按位异或 5 ^ 3得到6
~ 按位翻转 x的按位翻转是-(x+1) ~5得到6。
< 小于 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。 5 < 3返回0(即False)而3 < 5返回1(即True)。比较可以被任意连接:3 < 5 < 7返回True。
> 大于 返回x是否大于y 5 > 3返回True。如果两个操作数都是数字,它们首先被转换为一个共同的类型。否则,它总是返回False。
<= 小于等于 返回x是否小于等于y x = 3; y = 6; x <= y返回True。
>= 大于等于 返回x是否大于等于y x = 4; y = 3; x >= y返回True。
== 等于 比较对象是否相等 x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!= 不等于 比较两个对象是否不相等 x = 2; y = 3; x != y返回True。
not 布尔“非” 如果x为True,返回False。如果x为False,它返回True。 x = True; not x返回False。
and 布尔“与” 如果x为False,x and y返回False,否则它返回y的计算值。 x = False; y = True; x and y,由于x是False,返回False。在这里,Python不会计算y,因为它知道这个表达式的值肯定是False(因为x是False)。这个现象称为短路计算。
or 布尔“或” 如果x是True,它返回True,否则它返回y的计算值。 x = True; y = False; x or y返回True。短路计算在这里也适用。

[表]运算符优先级:

Python会首先计算表中较下面的运算符,然后在计算列在表上部的运算符,在表中列在同一行的运算符具有 相同优先级:

运算符 描述
lambda Lambda表达式
or 布尔“或”
and 布尔“与”
not x 布尔“非”
in,not in 成员测试
is,is not 同一性测试
<,<=,>,>=,!=,== 比较
| 按位或
^ 按位异或
& 按位与
<<,>> 移位
+,- 加法与减法
*,/,% 乘法、除法与取余
+x,-x 正负号
~x 按位翻转
** 指数
x.attribute 属性参考
x[index] 下标
x[index:index] 寻址段
f(arguments...) 函数调用
(experession,...) 绑定或元组显示
[expression,...] 列表显示
{key:datum,...} 字典显示
'expression,...' 字符串转换

流程控制

if语句

if语句用来检验一个条件, 如果条件为真则运行一块语句(称为if-块 ),否则处理另外一块语句(称为else-块 )。else从句是可选的。if语句在结尾处包含一个冒号,下面跟着一个语句块。if语句块中可以使用另外一个if语句块,称为嵌套的if语句。

#!/usr/bin/python
number = 23  # 设置变量number为一个整数。
guess = int(raw_input('Enter an integer : '))  # 使用内建的raw_input()函数取得输入的数字,通过int把输入的字符串转换为整数,并存储在变量guess中。
if guess == number:  # 如果输入值等于number
    print 'Congratulations, you guessed it.'
elif guess < number:  # 如果输入值小于number
    print 'No, it is a little higher than that'
else:
    print 'No, it is a little lower than that'
print 'Done'
输出:
#./if.py
Enter an integer : 50
No, it is a little lower than that
Done
#./if.py
Enter an integer : 22
No, it is a little higher than that
Done
#./if.py
Enter an integer : 23
Congratulations, you guessed it.
Done

while语句

只要在一个条件为真的情况下,while语句就会重复执行一块语句,直到条件为假才结束。while语句是所谓循环语句的一个例子。while语句有一个可选的else从句。

#!/usr/bin/python
number = 23  # 设置变量number为一个整数。
running = True  # 在while循环开始前把running变量设置为True。
while running:  # 检验变量running是否为True,然后执行后面的while-块。
    guess = int(raw_input('Enter an integer : '))
    if guess == number:  
        print 'Congratulations, you guessed it.'
        running = False
    elif guess < number:
        print 'No, it is a little higher than that'
    else:
        print 'No, it is a little lower than that'
else:  # 条件为假执行
    print 'The while loop is over.'
print 'Done'
输出:
#./while.py
Enter an integer : 50
No, it is a little lower than that.
Enter an integer : 22
No, it is a little higher than that.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

for循环

for..in是另外一个循环语句,它在一序列的对象上递归,就是逐一使用队列中的每个项目。

#!/usr/bin/python
for i in range(1, 5):  # 打印使用内建的range函数生成的一序列数。
    print i
else:
    print 'The for loop is over'
输出:
#./for.py
1
2
3
4
The for loop is over

在C/C++中写for (int i = 0; i < 5; i++),用Python可以写成for i in range(0,5)

break语句

break语句是用来终止循环语句的,即使循环条件没有称为False或序列还没有被完全递归,也停止执行循环语句。需要注意如果从for或while循环中终止,任何对应的循环else块将不执行。

#!/usr/bin/python
while True:
    s = raw_input('Enter something : ')
    if s == 'quit':  # 如果输入内容为quit,则执行break语句。
        break
    print 'Length of the string is', len(s)
print 'Done'
输出:
#./break.py
Enter something : Programming is fun
Length of the string is 18
Enter something : When the work is done
Length of the string is 21
Enter something : if you wanna make your work also fun:
Length of the string is 37
Enter something :       use Python!
Length of the string is 12
Enter something : quit
Done

continue语句

continue语句被用来跳过当前循环块中的剩余语句,然后重新进行下一轮循环。

#!/usr/bin/python
while True:
    s = raw_input('Enter something : ')
    if s == 'quit':  # 如果输入内容为quit,则执行break语句。
        break
    if len(s) < 3:  # 使用len()获取字符串长度,如果长度小于3,使用continue重新执行该循环。
        continue
    print 'Input is of sufficient length'

continue语句对于for循环也有效。

输出:
#./continue.py
Enter something : a
Enter something : 12
Enter something : abc
Input is of sufficient length
Enter something : quit

函数

函数就是给一块语句的一个名称,可以在程序的任何地方使用这个名称。这被称为调用函数。函数通过def关键字定义,def关键字后跟一个函数的标识符名称,然后跟一对圆括号。圆括号之中可以包括一些变量名,该行以冒号结尾。接下来是一块语句,它们是函数体。

定义函数:
def sayHello():  # 定义了一个名为sayHello的函数。
    print 'Hello World!'
sayHello()  # 使用这个函数。
#./function.py
Hello World!

函数形参

提供给函数的值就是函数取得的参数,这样函数就可以利用这些值做一些事情。这些参数就像变量一样,只不过这个值是在调用函数的时候定义的,而非在函数本身内赋值。参数在函数的圆括号对内指定,用逗号分割。当调用函数的时候,以同样的方式提供值。函数中的参数名称为形参,提供给函数调用的值称为实参

#!/usr/bin/python
def printMax(a, b):  # 定义一个名为printMax的函数,a和b是形参。
    if a > b:        # 使用if语句找出两者中较大的数,且打印那个数。
        print a, 'is maximum'
    else:
        print b, 'is maximum'
printMax(3, 4)  # 把实参3和4提供给函数。
x = 5
y = 7
printMax(x, y) # 使用变量调用函数,把实参x赋值给形参a,实参y赋值给形参b。
输出:
#./func_param.py
4 is maximum
7 is maximum

局部变量

在函数内部定义的变量,与函数外同名的其他变量没有任何关系,函数内的变量名称对于函数来说是局部的。局部变量的作用域是从定义的那点开始生效。

#!/usr/bin/python
def func(x):
    print 'x is', x  # 第一次打印x值,使用的是函数声明形参的值50。
    x = 2  # 声明局部变量x
    print 'Changed local x to', x  # 第二次打印x值,使用局部变量值2。
x = 50  # 函数外部的变量x
func(x)
print 'x is still', x  # 函数第三次打印x值,使用外部变量值50。
输出:
#./func.py
x is 50
Changed local x to 2
x is still 50

global语句

global语句是定义一个全局变量

#!/usr/bin/python
def func():
    global x  # 声明函数内部x变量是一个全局变量。
    print 'x is', x  # 第一次打印的x值为50,因为这个值声明在先。
    x = 2
    print 'Changed local x to', x  # 第二次打印x值为2,x被重新赋值为2。
x = 50
func()
print 'Value of x is', x  # 第三次打印x值为2,因为x已经被声明为全局变量,所以在函数以外也生效。
输出:
#./func_global.py
x is 50
Changed global x to 2
Value of x is 2

可以使用一个global语句一次指定多个全局变量。例如:global x, y, z

默认参数值

函数可以给形参赋予一个默认值,当在使用这个函数的时候没有为形参赋值的话,就之用这个默认值。赋值方法:形参 = 默认值。默认参数值是一个参数,默认参数值是不可变的。

#!/usr/bin/python 
def say(message, times = 1):  # 为函数的形参times设置了默认值为1。
    print message * times  # 打印message乘times的值。
say('Hello')  # 没有为形参times赋值,使用默认值1,所以打印一个Hello。
say('World', 5)  # 为形参times赋值为5,则打印5个World。
输出:
#./func_default.py
Hello
WorldWorldWorldWorldWorld

有默认值的形参必须在没有默认值的形参之后声明,例如:def func(a, b=5)是有效的,def func(a=5, b)是无效的

关键参数

关键参数就是通过命名为参数赋值

#!/usr/bin/python
def func(a, b=5, c=10):
    print 'a is', a, 'and b is', b, 'and c is', c
func(3, 7)
func(25, c=24)
func(c=50, a=100)
输出:
#./func_key.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

return语句

return语句用来从一个函数返回即跳出函数,也可选从函数返回一个值。

#!/usr/bin/python
def maximum(x, y):
    if x > y:
        return x
    else:
        return y
print maximum(2, 3)
输出:
#./func_return.py
3

没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。如果一个变量的值为None,可以表示它没有值。

文档字符串DocStrings

DocStrings可以帮助程序文档更加简单易懂,也可以在程序运行的时候,从函数恢复文档字符串!

#!/usr/bin/python
def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # 转换为整数。
    y = int(y)
    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'
printMax(3, 5)
print printMax.__doc__
输出:
#./func_doc.py
5 is maximum
Prints the maximum of two numbers.

    The two values must be integers.

文档字符串的惯例是一个多行字符串,它的首行以大写字母开始,句号结尾。第二行是空行,从第三行开始是详细的描述。

模块

模块是一个包含函数和变量的文件。为了在其他程序中重复使用模块,模块的文件名必须以.py为扩展名。

#!/usr/bin/python
import sys  # 用import语句输入sys模块,sys模块是一个包含了与Python解释器和它的环境有关的函数。
print 'The command line arguments are:'
for i in sys.argv:  # sys.argv变量是一个字符串的列表,包含了命令行参数的列表,即使用命令行传递给程序的参数。
    print i
print '\n\nThe PYTHONPATH is', sys.path, '\n'
输出:
./using_sys.py we are arguments
The command line arguments are:
using_sys.py
we
are
arguments

The PYTHONPATH is ['/home/swaroop/byte/code', '/usr/lib/python23.zip',
'/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
'/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload',
'/usr/lib/python2.3/site-packages', '/usr/lib/python2.3/site-packages/gtk-2.0']

脚本的名称总是sys.argv列表的第一个参数。所以在这里“using_sys.py”是sys.argv[0]、“we”是sys.argv[1]、“are”是sys.argv[2]以及“arguments”是sys.argv[3]。Python从0开始计数,而非从1开始。

模块的__name__

每个模块都有一个名称,在模块中可以通过语句来找出模块的名称,当一个模块被第一次输入的时候,这个模块的主块将被运行,这可以通过模块的__name__属性完成。

#!/usr/bin/python
if __name__ == '__main__':
    print 'This program is being run by itself'  # 每个Python模块都有它的__name__,如果它是'__main__',运行主模块。
else:
    print 'I am being imported from another module'  # 被其他程序输入时候运行。
输出:
#./using_name.py
This program is being run by itself
 
#python
>>> import using_name
I am being imported from another module
>>>

数据结构

数据结构就是可以处理一些数据的结构,或者说是用来存储一组相关数据的。在Python中有三种内建的数据结构:列表元组字典

列表

  • 列表就是处理一组有序项目的数据结构。
  • 每个项目之间用逗号,分割。
  • 列表中的项目应该包括在方括号[]中。
  • 可以添加删除或是搜索列表中的项目。
  • 列表是可变的数据类型

对象与类的入门

对象和类
列表是使用对象的一个例子。当使用变量i并给它赋值的时候,比如赋整数5,就可以理解创建了一个类(类型)int的对象(实例)i

类的方法
类的方法就是仅仅为类而定义地函数,仅在有一个该类的对象的时候,才可以使用这些功能。例如:Python为list类提供了append方法,这个方法让你在列表尾添加一个项目。例如mylist.append('an item')列表mylist中增加那个字符串。用点号来使用对象的方法

类的域
一个类也有域,它是仅仅为类而定义的变量。仅在有一个该类的对象的时候,才可以使用这些变量/名称。类也是通过点号使用,例如mylist.field

#!/usr/bin/python
shoplist = ['apple', 'mango', 'carrot', 'banana']  # 变量shoplist是一个购物列表,列表中可以添加任何种类的对象,包括数或其他列表。
print 'I have', len(shoplist),'items to purchase.'  # 使用len()函数打印列表的长度。
print 'These items are:',  # 结尾的逗号(,)是让打印结果在同一行,消除自动换行符。
for item in shoplist:  # 使用for循环递归所有列表中的项目,并打印。
    print item,
print '\nI also have to buy rice.'
shoplist.append('rice')  # 使用append方法在列表中添加一个项目rice。
print 'My shopping list is now', shoplist  # 打印添加新项目后的列表。

print 'I will sort my list now'
shoplist.sort()  # 使用列表的sort方法来对列表排序,这并不是修改列表,列表是可变的,而字符串是不可变的
print 'Sorted shopping list is', shoplist  # 打印排序后的列表。

print 'The first item I will buy is', shoplist[0]  # 打印列表中第一个项目,Python从0开始计数
olditem = shoplist[0]  # 设置变量olditem的值为列表中第一个项目。
del shoplist[0]  # 使用del语句删除列表中第一个项目。
print 'I bought the', olditem  # 打印变量olditem
print 'My shopping list is now', shoplist  # 打印删除shoplist[0]后的列表。
输出:
#./using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

元组

  • 元组和列表类似,只不过元组和字符串都是不可变的,即元组不能修改。
  • 元组通过圆括号()中用逗号,分割的项目定义
#!/usr/bin/python
zoo = ('wolf', 'elephant', 'penguin')  # 变量zoo是一个元组。
print 'Number of animals in the zoo is', len(zoo)  # 通过len()函数获取元组长度,说明元组也是一个序列。
new_zoo = ('monkey', 'dolphin', zoo)  # 新元组new_zoo的项目中包含了元组zoo,元组内的元组还是以元组的身份存在。
print 'Number of animals in the new zoo is', len(new_zoo)  # 获取新元组的长度。
print 'All animals in new zoo are', new_zoo # 打印新元组。
print 'Animals brought from old zoo are', new_zoo[2]  # 使用方括号[]来访问元组中的项目,这里是访问元组中第三个项目。
print 'Last animal brought from old zoo is', new_zoo[2][2] # 使用new_zoo[2][2]访问元组中第三个项目中的第三个项目。
输出:
#./using_tuple.py
Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin

列表之中的列表不会失去它的身份,同样元组中的元组,或列表中的元组,或元组中的列表等等都是如此。只要是Python,它们就只是使用另一个对象存储的对象。

元组与打印语句

元组最通常的用法是用在打印语句中:

#!/usr/bin/python
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age)  # print后面的%是输出制定的格式,如%s表示字符串,%d表示整数。后面的元组必须使用相同的顺序来对应这些制定的格式。
print 'Why is %s playing with that python?' % name  # %s被替换为变量name的值。单个项目可以没有圆括号()。
输出:
#./print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?

字典

字典类似于通过联系人名字查找地址和联系人详细情况的地址簿,就是把(名字)和(详细情况)联系在一起。键必须是唯一的,就像如果有两个人恰巧同名的话,无法找到正确的信息。

  • 只能使用不可变的对象(比如字符串)来作为字典的,但可以使用不可变或可变的对象作为字典的
  • 键值在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }键/值对使用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中
  • 字典中的键/值对是没有顺序的。如果想要一个特定的顺序,应该在使用前自己对它们排序。
  • 字典是dict类的实例/对象。
#!/usr/bin/python
ab = { 'Swaroop'   : 'swaroopch@byteofpython.info',
       'Larry'     : 'larry@wall.org',
       'Matsumoto' : 'matz@ruby-lang.org',
       'Spammer'   : 'spammer@hotmail.com'
     }  # 创建了字典ab,使用索引操作符来指定键,从而使用键/值对。
print "Swaroop's address is %s" % ab['Swaroop']  # 打印字典ab中第一个键的值。
ab['Guido'] = 'guido@python.org'  # 使用索引操作符来寻址一个键并为它赋值,这样就增加了一个新的键/值对。
del ab['Spammer'] # 使用del语句删除字典ab中键/值对。
print '\nThere are %d contacts in the address-book\n' % len(ab)  #获取字典长度。
for name, address in ab.items():  # 使用字典的items方法,获取字典中的每个键/值对,分别赋给for..in循环中的变量name和address然后在for-块中打印这些值。
    print 'Contact %s at %s' % (name, address)
if 'Guido' in ab:  # 使用in操作符来检验一个键/值对是否存在。
    print "\nGuido's address is %s" % ab['Guido']
输出:
#./using_dict.py
Swaroop's address is swaroopch@byteofpython.info
There are 4 contacts in the address-book
Contact Swaroop at swaroopch@byteofpython.info
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org
Contact Guido at guido@python.org
Guido's address is guido@python.org

序列

列表、元组和字符串都属于序列。序列的两个主要特点是索引操作符切片操作符

  • 索引操作符可以从序列中抓取一个特定项目。
  • 切片操作符能够获取序列的一个切片,即一部分序列。
#!/usr/bin/python
shoplist = ['apple', 'mango', 'carrot', 'banana']
# 使用索引来取得序列中的单个项目,这也被称作是下标操作。
print 'Item 0 is', shoplist[0] # 获取序列中第一个项目。
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1] # 获取序列中倒数第一个项目。
print 'Item -2 is', shoplist[-2]
# 切片操作:切片操作符是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割。
print 'Item 1 to 3 is', shoplist[1:3] # 获取项目1和3。
print 'Item 2 to end is', shoplist[2:] # 获取项目2到结束。
print 'Item 1 to -1 is', shoplist[1:-1] # 获取项目1和倒数第一的中间,就是排除头尾去中间。
print 'Item start to end is', shoplist[:] # 获取全部。
# 在字符串中使用切片操作
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]

以上访问序列的方法可以用在访问列表、元组和字符串。

输出:
#./seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

对象与参考

当创建一个对象并给它赋一个变量的时候,这个变量仅仅参考那个对象,而不是表示这个对象本身!也就是说,变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。

#!/usr/bin/python
print 'Simple Assignment'
shoplist = ['apple', 'mango', 'carrot', 'banana']  # 创建序列。
mylist = shoplist  # 复制序列shoplist为mylist。
del shoplist[0]  # 删除序列shoplist第一个选项。
print 'shoplist is', shoplist  # 打印序列shoplist。
print 'mylist is', mylist  # 打印序列mylist。
print 'Copy by making a full slice'
mylist = shoplist[:]  # 复制
del mylist[0]  # 删除
print 'shoplist is', shoplist
print 'mylist is', mylist
输出:
#./reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

如果要复制一个列表或者类似的序列或者其他复杂的对象(不是如整数那样的简单对象 ),那么必须使用切片操作符来取得拷贝。

更多字符串的内容

字符串也是对象,同样具有方法。这些方法可以完成包括检验一部分字符串和去除空格在内的各种工作。程序中使用的字符串都是str类的对象。

#!/usr/bin/python
name = 'Swaroop'  # 这是一个字符串对象
if name.startswith('Swa'):  #startwith方法是用来测试字符串是否以给定字符串开始。
    print 'Yes, the string starts with "Swa"'
if 'a' in name:  # in操作符用来检验一个给定字符串是否为另一个字符串的一部分。
    print 'Yes, it contains the string "a"'
if name.find('war') != -1:  # find方法用来找出给定字符串在另一个字符串中的位置,或者返回-1以表示找不到子字符串。
    print 'Yes, it contains the string "war"'
#str类有一个整洁的方法,它是以一个作为分隔符的字符串join序列的项目,它返回一个生成的大字符串。
delimiter = '_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)
输出:
./str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_Russia_India_China

5条评论

写评论
  • kay

    看完天书~~~~ :cry: 其实我想说,咱俩同名~~~你的链接已经放到首页 哈,握手~~~

    • 奔跑

      这么巧啊,这简直太巧合了

  • zhui

    Python现在几乎是“大牛”必懂的语言之一。
    大标题 python基本概念 那部分,python拼写错误了。。。
    我也是1987年的呢。
    嘿嘿 欢迎回访。

    • 奔跑

      呵呵,多谢提醒!!

      • zhui

        今天还看了一条新闻,特地来告诉你,Python的作者去Google面试的时候,告诉面试官说 I Wrote Python,结果Google在面试第十轮才知道原来他是Python的作者!其实我们作为读者应该能理解Google肯定知道这个,只是可能在和Python Writer 在做一个高深的游戏 哈哈

您必须登录后才可以发表评论。

本人从事电脑网络维护工作多年,对电脑配置较为熟悉,闲暇之余精心搜罗了目前主流电脑配置清单推荐给大家。紧跟市场动态,定期更新电脑硬件配置方案,扫除一切垃圾坑爹配置,提供最具性价比的电脑配置清单!本站涵盖内容包括:电脑组装机配置单、电脑组装机报价、电脑组装机教程等,另外还提供很多技术文章供您学习!