python 核心编程 第一部分

2.2

%s 表示由一个字符串来替换，而%d 表示由一个整数来替换，另外一个很常用的就是%f， 它
表示由一个浮点数来替换

 

print ('I am %s,%d years old !'%('kaili',8))

print ('momey %f'%7.356)


输出：
I am kaili,8 years old !
momey 7.356000

 

# 将输出重定向到日志文件
logfile = open(r'D:/pythontest/test.txt','a')
print ('Fatal error: invalid input!',file=logfile)
logfile.close()

重定向输出到日志文件中，'a'表示从日志最后一行追加
Fatal error: invalid input!

'''从用户那里得到数据输入的最容易的方法是使用input()内建函数。 它读取标准输入，
并将读取到的数据赋值给指定的变量。 你可以使用 int() 内建函数将用户输入的字符串转换
为整数'''

# 文本输入
user = input('qing shu ru')
print('shu ru:',user)

# 输入一个数值字符串(并将字符串转换为整数）
age = input('qing shu ru')
print('age is:%d'%(int(age)+5))

输出：
qing shu rutangjian
shu ru: tangjian
qing shu ru2
age is:7

 

Python 中的标准算术运算符
+ - * / // % **
加、减、乘、除和取余都是标准运算符。Python 有两种除法运算符，单斜杠用作传统除法，
双斜杠用作浮点除法（对结果进行四舍五入）。而浮点除法是真正的除法，不管操作数是什么类型，浮点除法总是执行真正的除法。
乘方运算符， 双星号(**)

有标准比较运算符， 比较运算根据表达式的值的真假返回布尔值：
< <= > >= == != <>

逻辑运算符：
and or not
使用逻辑运算符可以将任意表达式连接在一起，并得到一个布尔值

Python 是动态类型语言， 也就是说不需要预先声明变量的类型。 变量的类型和值在赋值
那一刻被初始化。变量赋值通过等号来执行。

Python 支持五种基本数字类型，其中有三种是整数类型。 
 
int (有符号整数) 
long (长整数) 
bool (布尔值) 
float (浮点值) 
complex (复数) 
下面是一些例子： 
Python 中有两种有趣的类型是 Python 的长整型和复数类型。请不要将 Python 的长整数
与 C 语言的长整数混淆。Python 的长整数所能表达的范围远远超过 C 语言的长整数， 事实上，
Python 长整数仅受限于用户计算机的虚拟内存总数。如果你熟悉 Java, Python 的长整数类似
于 Java 中的 BigInteger 类型。

从长远来看， 整型与长整型正在逐步统一为一种整数类型。从 Python2.3 开始，再也不会
报整型溢出错误， 结果会自动的被转换为长整数。在未来版本的 Python 中， 两种整数类型将
会无缝结合， 长整数后缀 “L”也会变得可有可无。 
布尔值是特殊的整数。 尽管布尔值由常量 True 和 False 来表示， 如果将布尔值放到一
个数值上下文环境中（比方将 True 与一个数字相加）， True 会被当成整数值 1， 而 False
则会被当成整数值 0。 复数（包括-1 的平方根, 即所谓的虚数）在其它语言中通常不被直接
支持（一般通过类来实现）

 

字符串赋值换行时如下：
gg = 'python ' \
     'is cool' \
     ' okok'
print(gg)

aa = 'ni hao' \
     '  a  ' \
     'shi  fff'
print(aa)


输出:
python is cool okok
ni hao  a  shi  fff

列表和元组有几处重要的区别。列表元素用中括号( [ ])包裹，元素的个数及元素的值可
以改变。元组元素用小括号(( ))包裹，不可以更改（尽管他们的内容可以）。元组可以看成是
只读的列表。通过切片运算( [ ] 和 [ : ] )可以得到子集，这一点与字符串的使用方法一样。

元组也可以进行切片运算，得到的结果也是元组（不能被修改）

字典是 Python 中的映射数据类型，工作原理类似 Perl 中的关联数组或者哈希表，由键-
值(key-value)对构成。几乎所有类型的 Python 对象都可以用作键，不过一般还是以数字或者
字符串最为常用。 
值可以是任意类型的 Python 对象，字典元素用大括号({ })包裹。

 

标准 if 条件语句的语法如下： 
if expression: 
    if_suite

Python 当然也支持 else 语句， 语法如下： 
if expression: 
    if_suite 
else: 
    else_suite

Python 还支持 elif （意指 “else-if ”）语句，语法如下: 
if expression1: 
    if_suite 
elif expression2: 
    elif_suite 
else: 
    else_suite

标准 while 条件循环语句的语法类似 if. 再说一次， 要使用缩进来分隔每个子代码块。 
while expression: 
    while_suite

语句 while_suite 会被连续不断的循环执行， 直到表达式的值变成 0 或 False; 接着
Python 会执行下一句代码。 类似 if 语句， Python 的 while 语句中的条件表达式也不需要用
括号括起来。 
>>> counter = 0 
>>> while counter < 3: 
... print 'loop #%d' % (counter) 
... counter += 1 
loop #0 
loop #1 
loop #2

Python 中的 for 接受可迭代对象（例如序列或迭代器）作为其参数，每次
迭代其中一个元素

range()函数经常和 len()函数一起用于字符串索引。 在这里我们要显示每一个元素及其
索引值： 
>>> foo = 'abc' 
>>> for i in range(len(foo)): 
... print foo[i], '(%d)' % i 
... 
a (0) 
b (1) 
c (2)

打开一个文件， 并显示它的内容到屏幕上

logfile = open(r'D:/pythontest/test.txt','r')
for i in logfile:
    print (i,end='')
# end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
#  end="" 可使输出不换行。双引号之间的内容就是结束的内容，
# 可以是空格，也可以是其他字符。默认为换行

logfile.close()

输出：
Fatal error: invalid input!
Fatal error: invalid input!

 

编译时会检查语法错误， 不过 Python 也允许在程序运行时检测错误。当检测到一个错误，
Python 解释器就引发一个异常， 并显示异常的详细信息。程序员可以根据这些信息迅速定位
问题并进行调试， 并找出处理错误的办法。 
要给你的代码添加错误检测及异常处理， 只要将它们封装在 try-except 语句当中。 try 
之后的代码组， 就是你打算管理的代码。 except 之后的代码组， 则是你处理错误的代码。

try:
    logfile = open(r'D:/pythontest/test.txt1','r')
    for i in logfile:
        print (i,end='')
    logfile.close()
except IOError as error:
    print(error)
#IOError，找不到文件时触发
输出：
[Errno 2] No such file or directory: 'D:/pythontest/test.txt1'

 

定义函数如下（使用def定义函数）：
def addMe2Me(x): 
    'apply + operation to argument' 
    return (x + x)

使用 class 关键字定义类。 可以提供一个可选的父类或者说基类; 如果没有合适的基类，
那就使用 object 作为基类。class 行之后是可选的文档字符串， 静态成员定义， 及方法定
义。 
class FooClass(object): 
"""my very first class: FooClass""" 
version = 0.1 # class (data) attribute 
def __init__(self, nm='John Doe'): 
"""constructor""" 
self.name = nm # class instance (data) attribute 
print 'Created a class instance for', nm 
def showname(self): 
"""display instance attribute and class name""" 
print 'Your name is', self.name 
print 'My name is', self.__class__.__name__ 
def showver(self): 
"""display class(static) attribute""" 
print self.version # references FooClass.version 
def addMe2Me(self, x): # does not use 'self' 
"""apply + operation to argument""" 
return x + x

在上面这个类中， 我们定义了一个静态变量 version, 它将被所有实例及四个方法共享，
__init__()， showname(), showver(), 及熟悉的 addMe2Me(). 这些 show*()方法并没有做什
么有用的事情， 仅仅输出对应的信息。 __init__() 方法有一个特殊名字， 所有名字开始和
结束都有两个下划线的方法都是特殊方法。 
当一个类实例被创建时， __init__() 方法会自动执行， 在类实例创建完毕后执行， 类
似构建函数。__init__() 可以被当成构建函数， 不过不象其它语言中的构建函数， 它并不创
建实例--它仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象的必要的初
始化工作。通过创建自己的 __init__() 方法， 你可以覆盖默认的 __init__()方法（默认的
方法什么也不做），从而能够修饰刚刚创建的对象。在这个例子里， 我们初始化了一个名为 name 
的类实例属性（或者说成员）。这个变量仅在类实例中存在， 它并不是实际类本身的一部分。
__init__()需要一个默认的参数， 前一节中曾经介绍过。毫无疑问，你也注意到每个方法都有
的一个参数， self. 
什么是 self ? 它是类实例自身的引用。其他语言通常使用一个名为 this 的标识符。
当一个实例被创建，__init__()就会被自动调用。不管这个__int__()是自定义的还是默认的。

 

函数 描述 
dir([obj]) 显示对象的属性，如果没有提供参数， 则显示全局变量的名字                                
help([obj]) 以一种整齐美观的形式 显示对象的文档字符串， 如果没有提供任何参
数， 则会进入交互式帮助。 
int(obj) 将一个对象转换为整数 
len(obj) 返回对象的长度 
open(fn, mode) 以 mode('r' = 读， 'w'= 写,'a'=追加)方式打开一个文件名为 fn 的文件 
 range([[start,]stop[,step]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start 
默认值为 0， step默认值为1。 
raw_input(str) 等待用户输入一个字符串， 可以提供一个可选的参数 str 用作提示信
息。 
str(obj) 将一个对象转换为字符串 
type(obj) 返回对象的类型（返回值本身是一个 type 对象！）

 

# 分别使用while 和 for 创建一个循环:
# (a)写一个while 循环，输出整数从 0 到 10。（要确保是从 0 到 10， 而不是从 0到9或从1到10）
a = 0
while a < 11:
    print(a)
    a +=1

# (b)做同(a)一样的事， 不过这次使用range()内建函数
for i in range(11):
    print(i)

# 条件判断 判断一个数是正数，还是负数， 或者等于 0. 开始先用固定的数值，然
# 后修改你的代码支持用户输入数值再进行判断
a = int(input('请输入数值'))
if a < 0:
    print('a is 负数')
elif a > 0:
    print('a is 正数')
else:
    print('a = 0')

# 循环和字串 从用户那里接受一个字符串输入，然后逐字符显示该字符串。先用 while 循
# 环实现，然后再用 for 循环实现

a = input("请输入字符串")
b = 0
while b < len(a):
    print(a[b])
    b += 1
    
c = input("请输入字符串")
for i in c:
    print(i)

# 循环和运算符 创建一个包含五个固定数值的列表或元组，输出他们的和。然后修
# 改你的代码为接受用户输入数值。 分别使用 while 和 for 循环实现
#使用while
# a = [1,2,3,4,5]
i = 0
b = 0
while i < len(a):
    b = b + a[i]
    i += 1
print(b)
# 使用for
a = [1,2,3,4,5]
b = 0
for i in a:
    b = b + i
print(b)

# # 接受用户输入数值，使用WHILE
a = list(input("请输入数值"))
i = 0
b = 0
while i < len(a):
    b = b + int(a[i])
    i += 1
print(b)

# 接受用户输入数值，使用for
a = list(input("请输入数值"))
b = 0
for i in a:
    b = b + int(i)
print(b)

# 注意，int类型的数值是不能直接转换成列表的，需要先转换成字符串STR类型，才能正常转换成列表

# 循环和运算符 创建一个包含五个固定数值的列表或元组，输出他们的平均值
a = [1.2312,2.5612,3.45,4,5.2]
b = 0
for i in a:
    b = i + b
b = b/len(a)
print(b)

# 带循环和条件判断的用户输入 使用 raw_input()函数来提示用户输入一个 1 和 100 之间的
# 数，如果用户输入的数满足这个条件，显示成功并退出。否则显示一个错误信息然后再次提示
# 用户输入数值，直到满足条件为止
while True:
    a = int(input('请输入1到100之间数值'))
    if 1<=a<=100:
        print('%d 满足条件'%a)
        break
    else:
        print('%d 不满足条件，请继续'%a)
        continue

 

分号( ; )允许你将多个语句写在同一行上，语句之间用分号隔开，而这些语句也不能在这行开始一个新的代码块。这里有一个例子：
import sys; x = 'foo'; sys.stdout.write(x + '\n') 
必须指出一点， 同一行上书写多个语句会大大降低代码的可读性，Python 虽然允许但不提倡你这么做

多重赋值
>>> x = y = z = 1 
>>> x 
1 
>>> y 
1 
>>> z 
1 
在上面的例子中，一个值为 1 的整数对象被创建，该对象的同一个引用被赋值给 x、y 和
z 。也就是将一个对象赋给了多个变量。当然，在 Python 当中，将多个对象赋给多个变量也是
可以的。

“多元”赋值
>>> x, y, z = 1, 2, 'a string' 
>>> x
1 
>>> y 
2 
>>> z 
'a string'
在上面的例子里， 两个整数对象（值分别为1和2）及一个字符串对象， 被分别赋值给
x, y 和 z。通常元组需要用圆括号（小括号）括起来，尽管它们是可选的。我们建议总是加上
圆括号以使得你的代码有更高的可读性。 
>>> (x, y, z) = (1, 2, 'a string')

Python 标识符字符串规则和其他大部分用 C 编写的高级语言相似： 
第一个字符必须是字母或下划线（_） 
剩下的字符可以是字母和数字或下划线 
大小写敏感 
标识符不能以数字开头；除了下划线，其他的符号都不允许使用。处理下划线最简单的方
法是把它们当成字母字符。大小写敏感意味着标识符 foo 不同于 Foo，而这两者也不同于 FOO。