python 文档

一. 准备知识

1. python 安装

安装完成后，在cmd 中输入

python ,查看版本；
exit() ：退出

2. 开发工具 --- pycharm

控制台运行程序：

(venv) C:\develop\python_3_8_2\Code\test>python Chapter_1\hello.py

3. python 程序是如何运行的？

源代码 ----》 解释器 ---》 010101（机器码）
.pyc 文件 CPython / JPython /PYPY 三种

二. 变量

1. 注释

单行： #
多行： """ / '''

2. 变量

变量：内存的别名

3. 变量类型

变量类型： type()
isinstance() : 来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

4. 关键字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>>

5. 输入

input()

6. 输出

print(*objects, sep='', end='\n', file=sys.stdout, flush=False)
- objects ， 输出的对象；
- sep， 分隔符（默认为空字符串）；
- end， 结束符（默认为换行符，默认换一行）；
- file， 输出流；
- flush， 是否强制刷新输出流（默认情况下不会轻质输出）；

#file
file_source = open('zen.txt', 'a+', encoding='utf-8')
print('人生苦短，我用python', file=file_source)
file_source.close()

7. 运算符

**  幂 - 返回x的y次幂 
//  取整除 - 返回商的整数部分（向下取整）
a%b  --->  r=a-b*(a//b)

# 交换两个数
a, b = 5, 10
a, b = b, a
print(a, b)

逻辑运算符

and / or / nor

运算符	逻辑表达式	描述实例
and	x and y	如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。
not	not x	如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

三. 流程控制

1. if

2. if-elif-else

3. 三元运算符

x = -1
y = x if x >= 0 else -x
print(y)

4. 省略表达式

5. while() 循环

6. for() 循环

range() : range (start, stop [, step])

start
stop
step ：步长
range(5) ===> range(0, 5) : [ 0, 5)

7. 循环跳出语句 break

8. 循环跳出语句continue : 跳出本次循环

9. 循环else子句

while -else
for - else
else 子句，循环正常离开时，执行的语句

for else语句可以总结成以下话。
如果我依次做完了所有的事情(for正常结束)，我就去做其他事(执行else)，若做到一半就停下来不做了（中途遇到break），我就不去做其他事了(不执行else)。

英文原文
A break statement executed in the first suite terminates the loop without executing the else clause’s suite. A continue statement executed in the first suite skips the rest of the suite and continues with the next item, or with the else clause if there is no next item.
中文译文
用 break 关键字终止当前循环就不会执行当前的 else 语句，而使用 continue 关键字快速进入下一论循环，或者没有使用其他关键字，循环的正常结束后，就会触发 else 语句。
与continue 语句没有关系

str = "hello world"
for item in str:
    if item == "l":
        break
    print(item)
else:
    print("打印完成")

四. 字符串

1. 字符串基础

单引号 / 双引号 / 三个单引号或三个双引号。

2. 索引

3. 切片

motto = "abcd,efg"
motto[0:2]
motto[1:]
motto[0:10:2]
motto[-5:-1] # 从小到大

切片区间从小到大
切片区间左开右闭
索引越界会报错
切片越界会自动处理

4. 字符串是不可变类型

mutable 可变类型
immmutable 不可变类型

5. 字符串常用方法 --- 内置方法

dir() 函数
不带参数时，返回当前范围内的变量、方法和定义的类型列表。

6. 字符串拼接方法 --- join() 函数

sep.join(iterable)
以 sep 作为分隔符，将 iterable 中所有的元素合并为一个新的字符串。 iteratable 可以是一个数组 / 元组等。

list_var = ['www', 'baidu', 'com']
str_var = '.'.join(list_var )

7. 大小写转换

upper()
lower()
title() ：所有单词都已大写开始，其余均为小写；
capitalize : 将字符串的第一个字符串转换为大写；（把…首字母大写）
swapcase ：大写的字母转换为小写，小写转为大写。

8. 5种字符串的检索方法

count() : 统计字符串里指定字符出现的次数；区分大小写。
find() ：
查找某字符串里是否包含被查询的子字符串；
如果找到，返回子串的索引，否则返回-1。
index() ： 没有找到时，抛出异常。
startwith() ：查寻字符串是否是以 指定子字符串开头。找到了返回True，否则返回False。
endwith()

9. 3种字符串的修剪方法： strip / lstrip/ rstrip

strip() : 移除字符串头尾的字符（默认为空格或换行符），不移除中间的字符串。
lstrip()
rstrip()

10. 字符串格式化

str = "the length of (%s) is %d" %('runoob',len('runoob'))
print(str)

% --- formatting : 用元组替换。
str.format() ： 通过{} 和：来替换以前的%。可以接受不限个参数，位置可以不按顺序。
f-sring : f或F修饰符引领的字符串（f'xxx 或 F'xxx）, 以大括号{}标明被替换的字段

#你好Allen，这是你登录的第3次, 本次消费99.5员
str = '你好{0}，这是你登录的第{1}次, 本次消费{2:.1f}员'.format('Allen', 3, 99.47)
print(str)
str1 = '你好{name}，这是你登录的第{time}次, 本次消费{count:.1f}元'.format(name=name, time=logInTime, count=count)
str2 = F'你好{name}，这是你登录的第{logInTime}次, 本次消费{count:.1f}元'

5.14 f-sring

表发生求值与函数调用
引号 / 大括号和反斜杠： 大括号内，不能使用转移符号 / 外边可以

5.15 f-string 自定义格式：对齐 / 宽度 / 符号 / 补零 / 精度 / 进制等

对齐： < 左对齐 / > 右对齐 / ^ 居中

s = 3.1415926
num = f'{s:<13}' # 占13位，左对齐
print(num)  '3.1415926    '

数字符号相关格式： + ：负数前加（-），正数前加（+）；（空格），负数前加（-），正数前加（空格）； - ，负数前加（-），正数前不加任何符号。
数字显示（进制）

      #0b  #0o
print(f'{123:#0x}')  #0x7b

宽度与精度：
width ：整数 width指定快读；
0width ：开头的0，指定高位用0补足宽度；
width.precision ： precision 显示精度；

a=123.456
print(f'{a:8.2f}')   #'  123.46'
print(f'{a:08.2f}')  #'00123.46'

s="hello"
print(f'{s:8.3s}')  #'hel     '   长度是8位，我只取3位。

千分位分隔符： ，或 _
其中 10进制，每 3个数分隔；
其余进制数，每4个数分隔；

b=1234567890.1234567
print(f'{b:_f}')

格式类型相关描述符
%Y %M %D

五. python list / tuple /dict / set

1. list

append : 末尾追加；
insert : 指定位置插入；

list_a = ['aa', 'bb', 'cc']
list_a.insert(2, 'ff')
print(list_a)   # ['aa', 'bb', 'ff', 'cc']

pop（） : 默认删除末尾元素， pop(1) 删除指定位置元素

2. tuple 元组

不可更改：赋值时，决定了所有的元素

# 声明
tuple_b = ('aa', 'bb', 'cc')

len(list_b)

3. dict 字典：键值对， map

查找速度快；
利用空间换时间。

dict_b ={'s':"Allen", 2:"bob", 3:"lucy"}
print(dict_b['s'])       #Allen
print(2 in dict_b)       #True
print(dict_b.get('s'))   #Allen
print(dict_b.items())    #dict_items([('s', 'Allen'), (2, 'bob'), (3, 'lucy')])

dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值.

4. set

集合（set）是一个无序的不重复元素序列。可视作：没有value的字典。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
一般用作去重或集合求并求交。

#创建格式：
parame = {value01,value02,...}
#或者
set(value)

集合求交 &，并集 |
增加元素add
删除 remove
当集合是由列表和元组组成时,set.pop()是从左边删除元素。（集合对list 或者tuple 升序）

六. 函数

1. 基本用法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]
---
def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return
---
#默认参数
def printme( str="hello" ):
---
#不定长参数
def print_args(s, *args):
    print(s,end='  ')
    for a in args:
        print(a, end='  ')
    return

# print_args('hello')
print_args('aaaa', 'a', 1 ,'b')  # aaaa  a  1  b  
---
# 参数次序可以变
def print_two(a, b):
    print(a,b)

print_two(b='bb', a='aa')   # aa bb

2. 内嵌和闭包

内嵌函数：函数里又嵌套一个函数

def fun1():   
    print('fun1()在被调用')   
    def fun2():       
        print('fun2()在被调用')
    fun2()

闭包：闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包.
闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用；
闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁。
global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量；
nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

3. lamba表达式：匿名表达式

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

七. 模块

1. import

在同一文件下的文件，可以直接import；

# hello.py
def print_hello():
    print("hello")
    return

#main.py
import hello
hello.print_hello()

2. from...import

这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

# hello.py
def print_hello():
    print("hello")
    return

#main.py
from hello import  print_hello
print_hello()

3. 不在一个路径下

import sys
sys.path.append

import sys
sys.path.append('C:\\develop\\python_3_8_2\\Code\\test\\Chapter_1\\hello')
from hello import print_hello
print_hello()

4. 包：一个目录及子目录组成一个包（可以看作一个库）。

 if __name__ == '__main__'

新建一个文件夹；
文件夹下，新建一个 init.py文件。可以为空。

import sys
sys.path.append('C:\\develop\\python_3_8_2\\Code\\test\\Chapter_1\\hello\\package_test')

import package_test.hello as hl
hl.print_hello()

5. 标准库

八. 类

1. 类基本定义

# 类定义
class Human(object):
    pass

# 类属性 : 这个属性和类绑定， 并不是和实例绑定
class Human(object):
    taisheng = True # 胎生

# 实例属性 ： 这个name是和实例绑定的
class Human(object):
    def __init__(self, name): # 构造函数
        self.name = name

human_a = Human("Allen")


# 类方法
class Human(object):
    def __init__(self, name): # 构造函数
        self.name = name
    def walk(self):
        print(self.name + " is walking")

human_a = Human("Allen")
human_a.walk() # Allen is walking

访问控制： 如果不想外部直接访问，则在属性前面加__name（_name protected）。这样外部就无法访问，如果还想访问，则get方法。

2. 继承

3. 方法继承

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

九. python 文件读写

open(file, mode='r')
[file.readline([size])]  # 读取整行，包括 "\n" 字符， 字节数；

# 写
f = open("zen.txt", 'a+')
content = f.read()
f.write('hhh')
f.close()

f = open("zen.txt", 'a+')
content = f.read()
f.writelines(['hhh', 'lll'])
f.close()

十. python 异常

1. try ... except

try:
    f = open("111qwqw111.txt", 'r')
except OSError:
    print('文件出错T_T')


try:
    f = open("111qwqw111.txt", 'r')
except OSError as err:
    print('错误的原因是：' + str(err)) #错误的原因是：[Errno 2] No such file or directory: '111qwqw111.txt'

2. try - finally

finally : 无论如何都会被执行的代码。

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

3. raise 语句：引发一个异常

raise AAAA("除数为零的异常")
raise NameError("qq", 1111)

十一. 迭代器和生成器

1. 迭代器

for each in list

iter()
next()
_iter_() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 _next_() 方法并通过 StopIteration 异常标识迭代的完成。
_next_() 方法会返回下一个迭代器对象。

it = iter("hello")
print(next(it))

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)) #1
print(next(myiter)) #2
print(next(myiter)) #3
print(next(myiter)) #4
print(next(myiter)) #5

2. 生成器 yield

中断

def myGen():
    print("生成器被执行")
    yield 1
    yield 2

myG = myGen()
print(next(myG)) # 1
print(next(myG)) # 2

十二. 图形用户界面： EasyGui

安装完之后，安装文件在： C:\develop\python_3_8_2\Lib\site-packages\easygui.py

# 参考文档 https://blog.csdn.net/qiaoermeng/article/details/99718378
#from easygui import *
import easygui as g
import sys

while 1:
    g.msgbox("嗨，欢迎进入第一个界面小游戏^_^")

    msg = "请问你希望在鱼C工作室学习到什么知识呢？"
    title = "小游戏互动"
    choices = ["谈恋爱", "编程", "OOXX", "琴棋书画"]

    choice = g.choicebox(msg, title, choices)

    # note that we convert choice to string, in case
    # the user cancelled the choice, and we got None.
    g.msgbox("你的选择是: " + str(choice), "结果")

    msg = "你希望重新开始小游戏吗？"
    title = "请选择"

    if g.ccbox(msg, title):  # show a Continue/Cancel dialog
        pass  # user chose Continue
    else:
        sys.exit(0)  # user chose Cancel