目录

1 Python语法——编码规范和注释

2 Python变量

2.1 变量名

2.2 全局变量

3 数据类型

3.1 字符串

3.1.1 切片

3.1.2 len()——返回字符串的长度

3.1.3 字符串内置方法

3.1.4 一些技巧

3.2 数字

3.3 bool

4 运算符

5 四种收集数据类型

5.1 列表——list，[]

5.2 元组——tuple，()

5.3 集合——set，{}

5.4 字典——{key:value}

6 循环

7 函数

8 类，对象和继承

8.1 创建一个类和对象

8.1.1 __init __()函数——双下划线

8.1.2 对象方法

8.1.3 自我参数

8.1.4 修改对象属性

8.1.5 删除对象属性

8.2 继承

8.2.1 创建派生类

8.2.2 super()函数

8.3 迭代器

8.3.1 可迭代的对象

8.3.2 创建迭代器对象

9 模块

9.1 创建模块和使用模块

9.2 命名模块和重命名模块

9.3 内建模块

9.4 dir()函数

9.5 从模块中导入——from

10 异常处理

10.1 python标准异常

10.2 异常和异常处理

10.3 except带多种异常类型

10.4 异常的参数

10.5 raise抛出异常

10.6 用户自定义异常

11 文件I/O

11.1 打开文件

11.2 读取文件

11.3 写入字符

1、python

Python是一种解释型编程语言，这意味着作为开发人员，您需要在文本编辑器中编写Python（.py）文件，然后将这些文件放入python解释器中以执行。

python是面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。 

2、模块

python存在很多模块，导入模块后即可使用模块中的方法

import module

http://www.dooccn.com/jc/python/python_string_formatting.html

1 Python语法——编码规范和注释

1、编码规范

Python使用缩进来指示代码块。空格数量由您决定，但必须至少一个。

您必须在同一代码块中使用相同数量的空格，否则Python将给您一个错误，以下代码为语法错误

if 5 > 2:
 print("Five is greater than two!")
        print("Five is greater than two!")

2、注释

注释以开头#；注释可以放在一行的末尾；Python没有多行注释的语法。

3、多行注释

由于Python会忽略未分配给变量的字符串文字，因此您可以在代码中添加多行字符串（三引号）——即一个字符串使用多行来定义，并将注释放入其中

 

2 Python变量

变量是用于存储数据值的容器。

Python没有用于声明变量的命令。

变量是在您首次为其分配值时创建的。

变量不需要使用任何特定类型声明，甚至可以在设置变量后更改类型

可以使用单引号或双引号声明字符串变量

2.1 变量名

Python变量名规则：

字母或下划线字符开头，不能以数字开头

只能包含字母，数字，下划线

区分大小写

2.2 全局变量

在函数外部创建的变量。

函数内部的同名变量会屏蔽全局变量

1、全局关键字

global关键字，可以用来在函数内部创建全局变量

要在函数内部更改全局变量，使用global关键字引用该变量

 

3 数据类型

文字类型： str

数值类型： int，float， complex——int或float可以转换为complex类型，反向不行

序列类型： list，tuple， range

映射类型： dict

集合类型： set， frozenset

布尔类型： bool

二进制类型： bytes，bytearray， memoryview

type()函数获取任何对象的数据类型：

3.1 字符串

Python中的字符串是表示unicode字符的字节数组。

但是，Python没有字符数据类型，单个字符就是长度为1的字符串。

方括号可用于访问字符串的元素。

3.1.1 切片

您可以使用slice语法返回一定范围的字符。

指定起始索引和结束索引，以冒号分隔，以返回字符串的一部分——a = "Hello", print(a[1:3])

使用负索引，从字符串尾部开始计算，返回字符串的一部分

3.1.2 len()——返回字符串的长度

a = "Hello world"

print(len(a))

3.1.3 字符串内置方法

1、strip()——从开头或结尾删除所有空格

2、lower()——以小写形式返回字符串

3、upper()——以大写形式返回字符串

4、replace()——将一个字符串替换另一个字符串

a = "Hello World"

print(a.replace("H", "J")

5、split()——如果找到分隔符的实例，则使用分割符将字符串拆分为子字符串。

a = "Hello, World"

print(a.split(","))  #return ["Hello"," World"]

3.1.4 一些技巧

1、检查字符串

要检查字符串中是否存在某个短语或字符，我们可以使用关键字 in或not in

txt = "The rain in Spain stays mainly in the plain"
x = "ain" not in txt
print(x) 

2、字符串串联

要连接或组合两个字符串，可以使用+运算符。

3、字符串格式

使用format()方法将字符串和数字结合起来

format()方法采用传递的参数，对其进行格式化，然后将其放置在占位符所在的字符串中 {}

4、转义字符

要在字符串中插入非法字符，请使用转义字符。

转义字符是反斜杠，后跟要插入的字符。

3.2 数字

int，float，complex

int，float可以使用complex(int/float)转换为complex，但是反向不行

1、随机数

Python没有产生random()随机数的功能，但是Python有一个称为的内置模块 random，可用于产生随机数

import random

print(random.randrange(1, 10))

3.3 bool

bool()函数可以评估任何值，返回True或False

 

4 运算符

算术运算符——+，-，*，/，%，**（幂），//（取整除）

赋值运算符——=，+=，-=，*=，/=，%=，//=，**=，&=，|=，^=，>>=，<<=

比较运算符——==，!=，>，<，>=，<=

逻辑运算符——and，or，not

身份运算符——？？

成员运算符——in，not in

位运算符——&，|，^，~，<<，>>

 

5 四种收集数据类型

Python编程语言中有四种收集数据类型：

• 列表是有序且可更改的集合。允许重复的成员。
• 元组是有序且不可更改的集合。允许重复的成员。
• Set是无序和未索引的集合。没有重复的成员。
• 字典是无序，可变和索引的集合。没有重复的成员。

5.1 列表——list，[]

1、可以通过索引访问——正负索引均可

thelist = [1, 2, 3, 4, 5, 6]

thelist[1], thelist[-3]

2、可以指定索引范围获取子列表

thelist[2 : 4]

3、len()返回列表项数

4、append(value)，将项目添加到列表末尾——成员函数

5、insert(index, value)，在指定位置插入项目

6、remove(value)，从列表中删除项目

pop(index)，删除指定的索引

del thelist[0]，删除指定索引

del thelist，删除整个列表

7、copy()，返回复制的列表——成员函数

8、合并两个表

+

append(value)，追加元素

extend(thelist)，将一个

5.2 元组——tuple，()

元组有序且不可改变——元即意味着不可分割

1、索引访问

2、如何更改元组的值

先把元组赋给列表，修改列表

在把列表赋给元组

3、元组长度——len()

4、如果元组只有一个元素，则在元素后添加逗号——thistuple = ("apple",)

5.3 集合——set，{}

1、无序，无索引。无法通过索引或键来访问集合中的项目

2、add(value)——将项目添加到集合，成员函数

3、update()——将多个项目添加到集合，成员函数。update(["orange", "mango", "grapes"])

4、len()——获取集合的长度

5、remove(value)——删除某个项目

discard(value)——删除某个项目，如果项目不存在不会引发错误

pop()——删除最后一个项目，但是set是无序的，不知道删除的项目

6、clear()——清空集合

7、union(set)——返回包含两个集合的所有项目的新集合，成员函数

5.4 字典——{key:value}

字典是无序，可更改和索引的集合。在Python中，字典用大括号括起来，并且具有键和值。

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

 

1、[]——方括号内引用其键名来访问字典的各项

2、get(key)——键名来访问字典的各项，成员方法

3、values()——方法返回字典的值

for x in thisdict.values():
  print(x)

4、items()——使用以下 方法循环遍历键和值

for x, y in thisdict.items():
  print(x, y)

5、pop(key)——成员函数，删除具有指定键名的项目

6、popitem()——成员函数，方法删除最后插入的项

7、del——关键字，删除与指定键名称的项目

8、clear()——clear()方法清空字典

9、copy()——成员函数，复制字典

10、dict() ——功能复制字典

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = dict(thisdict)
print(mydict)

dict()就是词典的构造函数

6 循环

 

 

7 函数

def myfunc(*args):
    for i in range(len(args)):
        print(args[i])
        
myfunc(100, 10, 0)
myfunc(10, "I am fine", True)

 

 

 

8 类，对象和继承

Python是一种面向对象的编程语言。

Python中的几乎所有东西都是具有其属性和方法的对象。

类就像对象的构造函数，或者是创建对象的“蓝图”。

8.1 创建一个类和对象

要创建一个类，请使用关键字class。——class定义不能为空，但是如果由于某种原因而有一个class不包含任何内容的定义，请放入pass语句中，以避免出错。

class myclass:
    name = "Yu"
    age = 23
    job = "IT"

p1 = myclass()
print(p1.name, p1.age, p1.job)
print(type(p1))

#Yu 23 IT
#

 

8.1.1 __init __()函数——双下划线

python没有声明，首次创建时即分配值

要了解类的含义，我们必须了解内置的__init __（）函数。

所有类都有一个名为__init __（）的函数，该函数始终在启动类时执行。

使用__init __（）函数为对象属性或创建对象时必须执行的其他操作分配值。

__init__()每次使用该类创建新对象时，都会自动调用该函数。

class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job

o1 = myclass("Yu", 23, True, "IT")
print(o1.name, o1.age, o1.sex, o1.job)

输出——

8.1.2 对象方法

对象中的方法是属于该对象的函数。

class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job
   def myfunc(self):
       print('my name is ', self.name)
       print('my job is ', self.job)

o1 = myclass("Yu", 23, True, "IT")
o1.myfunc()

该self参数是对类的当前实例的引用，并用于属于类访问的变量

8.1.3 自我参数

self参数是对类的当前实例的引用，并用于属于类访问的变量

不必命名self，可以随意命名，但它必须是该类中任何函数的第一个参数

8.1.4 修改对象属性

class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job
   def myfunc(self):
       print('my name is ', self.name)
       print('my job is ', self.job)

o1 = myclass("Yu", 23, True, "IT")
o1.age = 40
o1.myfunc()

my name is  Yu
my age is  40
my job is  IT

8.1.5 删除对象属性

可以使用del关键字删除对象的属性：

class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job
   def myfunc(self):
       print('my name is ', self.name)
       print('my age is ', self.age)
       print('my job is ', self.job)

o1 = myclass("Yu", 23, True, "IT")
o1.age = 40
del o1.age
o1.myfunc()

输出

8.2 继承

继承允许我们定义一个类，该类从另一个类继承所有方法和属性。

父类是从其继承的类，也称为基类。

子类是从另一个类（也称为派生类）继承的类。

子类的方法遵循同名覆盖原则。

8.2.1 创建派生类

要创建一个从另一个类继承功能的类，请在创建子类时将父类作为参数发送

1、使用父类方法要用父类名来调用

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job
   def myfunc(self):
       print('my name is ', self.name)
       print('my age is ', self.age)
       print('my job is ', self.job)

#继承未扩展新的方法
class mysubclass_1(myclass):
    pass

#继承并扩展新的方法
class mysubclass_2(myclass):
    def __init__(subself, name, age, sex, job, height):
        myclass.__init__(subself, name, age, sex, job)
        subself.height = height
    def myfunc(subself):
        myclass.myfunc(subself)
        print('my height is ', subself.height)

psub_1 = mysubclass_1("Yu", 24, True, "IT")
psub_1.myfunc()

psub_2 = mysubclass_2("Yu2", 44, True, "IT_Author", 175)
psub_2.myfunc()

2、使用类本身的方法也要用类名来调用

class Base:
   def __init__(self):
       self.mark = "rwxrwsrwt"
       self.value = 100
   def init(self, value):
       Base.__init__(self)
       self.value = value
   def show(self):
       print("my mark is ", self.mark)
       print("my value is ", self.value)

p = Base()
p.init(800)
p.show()

 

8.2.2 super()函数

super()函数可以使子类从其父类继承所有方法和属性

通过使用该super()函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性

class myclass:
   def __init__(self, name, age, sex, job):
       self.name = name
       self.age = age
       self.sex = sex
       self.job = job
   def myfunc(self):
       print('my name is ', self.name)
       print('my age is ', self.age)
       print('my job is ', self.job)

#继承未扩展新的方法
class mysubclass_1(myclass):
    pass

#继承并扩展新的方法
class mysubclass_2(myclass):
    def __init__(subself, name, age, sex, job, height):
        super().__init__(name, age, sex, job)
        subself.height = height
    def myfunc(subself):
        super().myfunc()
        print('my height is ', subself.height)

psub_1 = mysubclass_1("Yu", 24, True, "IT")
psub_1.myfunc()

psub_2 = mysubclass_2("Yu2", 44, True, "IT_Author", 175)
psub_2.myfunc()

使用super()函数，第一参数就不需要类当前实例的引用了。

 

8.3 迭代器

迭代器是一个对象，其中包含可计数的值。

迭代器是可以迭代的对象，这意味着您可以遍历所有值。

从技术上讲，在Python中，迭代器是实现迭代器协议的对象，该协议由方法__iter__() 和组成__next__()。

8.3.1 可迭代的对象

1、列表，元组，字典和集合都是可迭代的对象。它们是可迭代的 容器，您可以从中获得迭代器。

所有这些对象都有一个iter()用于获取迭代器的方法，并用next()访问下一迭代器

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))



mystr = "banana"
myit = iter(mystr)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

 

2、可以使用for循环来迭代可迭代对象

mytuple = ("apple", "banana", "cherry")

for x in mytuple:
  print(x)

mystr = "banana"

for x in mystr:
  print(x)

for循环实际上创建了一个迭代器对象，并为每个循环执行next()方法

8.3.2 创建迭代器对象

要将对象/类创建为迭代器，必须实现方法 __iter__()和__next__()实现对象。

正如您在“ Python类/对象”一章中所了解的那样，所有类都有一个名为的函数__init__()，该函数可让您在创建对象时进行一些初始化。

__iter__()方法的行为类似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。

__next__()方法还允许您执行操作，并且必须返回序列中的下一项。

#创建一个返回数字（从1开始）的迭代器，每个序列将增加一个（返回1,2,3,4,5等）
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

如果您有足够的next（）语句，或者如果在for循环中使用它，则上面的示例将永远持续下去

为了防止迭代永远进行，我们可以使用该 StopIteration语句。

在该__next__()方法中，如果迭代执行了指定的次数，我们可以添加终止条件以引发错误

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

 

总结：

（1）__iter__()要返回迭代器本身，__next__()要返回序列的下一项

（2）实现了__iter__()和__next()__的迭代器函数不需要实现__init__()函数——__init__()是内置函数，无论你是否实现它都在那里，可能为空

 

9 模块

模块与代码库相同。

包含在应用程序中的一组功能的文件。

9.1 创建模块和使用模块

1、要创建模块，只需将所需的代码保存在带有文件扩展名的文件中.py

2、使用import语句导入要使用的模块

（1）使用模块中的函数时，使用语法：module_name.function_name。

（2）模块可以包含函数，也可以包含所有类型的变量（数组，字典，对象等）

9.2 命名模块和重命名模块

1、可以随意命名模块文件，但文件扩展名必须是 .py

2、导入模块时，可以使用as关键字创建别名——import mymodule as mx

9.3 内建模块

Python中有几个内置模块，可以随时将其导入——platform，sys等

9.4 dir()函数

dir()内置函数可以列出模块中的所有函数名称（或变量名称）

dir（）函数可以在所有模块上使用，也可以在自己创建的模块上使用。

import sys
def myfunc():
    d = dir(sys)
    for member in d:
        print(member)

myfunc()

输出：

['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__', '_base_executable', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework', '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook', 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix', 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'pycache_prefix', 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info', 'warnoptions']

9.5 从模块中导入——from

使用from关键字选择仅从模块中导入零件

from sys import version
from sys import version_info

print(version)
print(version_info)

输出

10 异常处理

try块使您可以测试代码块是否存在错误。

except块使您可以处理错误。

finally块使您可以执行代码，而不管try-和except块的结果如何。

10.1 python标准异常

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
SystemExit	Python 解释器请求退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
KeyboardInterrupt	用户中断执行(通常是输入^C)
LookupError	无效数据查询的基类
IndexError	序列中没有没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

10.2 异常和异常处理

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

10.3 except带多种异常类型

使用函数参数列表列出多种异常类型

def TEF_test2(value):
    try:
        if value > 0:
            raise Exception(["value", "is", "bigger", "than", "1"])
        print(5/value)
        show()
    except (ZeroDivisionError, NameError, NotImplementedError):
        print("There is a illegal number")
    except Exception as ls:
        print(ls, "How does it differ different errors")

ZeroDivisionError——除数是0

NameError——不存在的具名变量

NotImplementedError——未实现的方法

10.4 异常的参数

这里args是一个Exception的实例

def temp_convert(var):
   try:
      if type(var) != int:
          raise Exception(var, "is invalid argument")
   except Exception as e:
      print(e.args[0])

# Call above function here.
temp_convert("xyz")

从输出结果来看，Exception是一个类，且其__init__()函数是一个多参数函数

10.5 raise抛出异常

def temp_convert(var):
   try:
      if type(var) != int:
          raise Exception(var, "is invalid argument")
   except Exception as args:
      print(args)
   else:
       print("nothing")

10.6 用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。

异常应该是典型的继承自Exception类，通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

try:
   raise Networkerror("Bad hostname")
except Networkerror as e:
   print(e.args)
   print(type(e))
   print(type(e.args))

从输出可以看出，这里的参数实际变成了元组。

因为args是一个任意参数，这里把每一个字符都当做了参数这里使用的

args应该是任意类的内置参数，表示__init__()的所有参数——这里有点像函数重载

 

11 文件I/O

Python具有几个用于创建，读取，更新和删除文件的功能。

1、读取键盘的输入

raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）

input()是阻塞式的，执行input()函数，python会停止等待用户输入完后再执行

11.1 打开文件

在Python中处理文件的关键功能是 open()函数。

该open()函数有两个参数； 文件名和模式。

1、打开文件有四种不同的方法（模式）：

"r"-读取-默认值。打开文件进行读取，如果文件不存在，则错误

"a" -追加-打开要追加的文件，如果不存在则创建文件

"w" -写入-打开文件进行写入，如果不存在则创建文件

"x" -创建-创建指定的文件，如果文件存在则返回错误

2、您可以指定文件应以二进制还是文本模式处理

"t"-文本-默认值。文字模式

"b" -二进制-二进制模式（例如图像）

f1 = open("demofile1.txt", "rt")

f2 = open("demofile2.txt", "at")

f3 = open("demofile3.txt", "wt")

f4 = open("demofile4.txt", "xt")

f5 = open("demofile5.txt", "rb")

f6 = open("demofile6.txt", "ab")

f7 = open("demofile7.txt", "wb")

f8 = open("demofile8.txt", "xb")

11.2 读取文件

open()函数返回一个文件对象，该对象具有一种 read()读取文件内容的方法

read()方法返回整个文本，但也可以指定要返回的字符数

readline()方法返回一行

f2 = open("demofile2.txt", "at")
f2.write("Now create a filenThere is a bookn I am a man who like basketballn")
f2.close()

f2 = open("demofile2.txt", "rt")

str1 = f2.read(10)
print(str1)
str2 = f2.readline()
print(str2)

for line in f2:
    print(line)

11.3 写入字符

write()