python 核心编程 章节2

Posted 2021-12-01 biqiuqiu

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__()是自定义的还是默认的。