python自学程序员python基础笔记

python3 学习笔记

2018-12-02  本文已影响32人  jouyouyun

Python3 Study Notes

本人很少写 python 代码, 一般都是用 go 的, 去年时用 python 写过一些收集系统信息的工具, 当时是边看手册边写的. 如今又要用 python 来写一个生成 xlsx 的工具, 就又需要查看手册了, 至于为什么不用 go 写? 那是因为 go 的库不兼容永中. 在这里不得不说, 虽然 go 很火, 但是一些库还是不如 python 多, 不如 python 兼容性好.

为了避免以后再出这种事情, 这次就好好的了解下 python, 将它的用法按照自己对语言的理解分块记录下来. 要使用某种语言, 个人认为需要了解这些方面:

还有一些就是此语言的一些特性, python 就还需要了解以下特性:

下文就将按照这些内容来一一记录.

编码风格

变量

Python 是动态语言, 变量的类型不固定, 根据值的类型而决定, 所以不用显示的声明变量， 用的时候直接赋值即可，如下:

a = 1; // 此时是整型
print(a);
a = 'hello'; // 此时又为字符串类型

通常变量名全部大写的为 常量, 空值 用 None 表示.

以 _xxx 或 __xxx 命名的函数或变量是私有变量, 不能被其他模块直接引用

基础类型

这里将整型, 浮点型, 布尔和字符串看作是基本类型, 整型和浮点型的使用就不再介绍了, 布尔的值只能为 True/False, 而字符串的常见操作如下:

另外它们之间的相互转换是通过 int(arg), float(arg), str(arg) 这些内置的方法来处理的.

列表

列表中可以包含不同类型的数据, 如:

list = ["eggs", 1, 67.12];

通过 list(seq) 可以将一个序列转换为列表.

array 模块提供了固定类型的数据, 可以指定要转换的类型, 具体请查阅手册.

列表通过下标索引, len 函数获取大小.

列表对象常用的方法如下:

列表遍历:

for <variable> in <array>:
    // do

// 带下标
for idx, name in enumerate(<array>):
    // do

// 列表中多个元素
for x, y in [(1, 1), (2, 4), (3, 9)]:
    // do

// 用 zip 同时遍历多个数组
a = [1, 2];
b = [5, 6];
for av, bv in zip(a, b):
    // do av=1, bv=5

// 生成
[x * x for x in range(1, 11) if x % 2 == 0]

元组

元组(tuple) 是一个不可修改的列表, 元组中每个元素的指向是不可更改的, 但指向里的内容是可以更改的, 如元组中包含一个数组:

t = ('1', 1, ["A", "B"]);
t[2][0] = "X";
t[2][1] = "Y";

字典

语法:

dict = {'<key>':<value>}

常用的对象方法:

使用字典需要注意以下几点:

集合

集合与字典类似, 是一组 key 的集合, 但不存储 value, 没有重复的 key.

要创建一个集合, 需要传入一个数组, 重复的元素会被自动过滤.

遍历:

for <key> in <dict>:
    // do

// 带下标
for idx, name in dict.items():
    // do

s = set([1, 2, 3 ,3]); // s: {1,2,3}

常用的对象方法:

global 关键字

global 关键字用于声明变量的作用域, 用法如下:

# 全局变量
a = 1

def test():
    # 若下面这行注释掉, 则下面的 a 是局部变量, 'Global' 处的输出还是全局变量 1
    # 若下面这行取消注释, 则下面的 a 是全局变量, 'Gloabl' 出的输出是 5
    # global a
    a = 5
    print("In test:", a)

# Global
print("Global:", a)

输出, global a 注释掉时:

In test: 5
Global: 1

输出, global a 取消注释时:

In test: 5
Global: 5

更多

上面的只是基础，想要更好的使用变量，还需要了解以下内容：

输入/输出

输入

使用 raw_input(prompt) 可以接受控制台的输入

输出

使用 print() 可以打印内容到控制台, 格式化输出:

n = 1;
s = "Joy";
print("The %d student's name is %s" % (n, s));

也可以使用 format 来格式化, 它会用传入的参数依次替换字符串内的占位符 {0}、{1}…… :

// {3:.1f} 表示保留一位小数
s = "The {0} student's name is {1}, score: {3:.1f}".format(1, "Joy", 87.75);
print(s);

控制语句

控制语句中可以使用 break, continue, pass 关键字, break 与 continue 的作用与其他语言中的一样, pass 则是一个空语句, 不做任何事情, 一般是为了保持结构的完整性, 常被用来占位, 表明之后会实现.

注意: python 中没有 goto 和 switch.

IF

语法:

if <condition>:
elif <condition>:
else:

FOR

for <variable> in <array>:
    // do
else:

else 可选

WHILE

while <condition>:
    // do
else:

else 可选

错误处理

语法:

try:
    // do
except <error type> as e:
   // do
except <error type> as e:
else:
   // no error
finally:
   // do

如果 finally 存在, 则无论有没有异常都会执行, else 则在 except 都没进入时才执行.

函数

语法:

def func(arg1, arg2=value, arg3=value):
    // do
    return ret1, ret2

# 不定长参数
def func(arg1, *vartuple):
   "打印所有参数"
   print(arg1)
   for var in vartuple:
       print(var)
   return

定义函数时可以给参数指定默认值, 这样在调用时就可以不传入这些参数, 没有默认值的参数是必须要传入的.

定义默认参数要牢记一点：默认参数必须指向不变对象(数, 字符串, 元组)！

参数前加了 * 的变量会存放所有未命名的变量.

__name__ 是函数对象的一个属性, 可以拿到此函数的名称

Lambda

使用关键字 lambda, 就可以创建短小的匿名函式, 如:

# 语法
lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 10) # 20
print(sum(10, 20) # 30

特点:

装饰器

当需要增强某个函数的功能时, 但有不希望修改函数, 此时可以使用装饰器. 如添加日志功能:

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def test():
    print("Test")

通过 @ 语法就给函数 test 添加了日志功能

模块

模块就是一个 python 文件, 使用 import 导入模块, 调用模块中的方法时就必须以 <module>.<func> 来调用.

from <module> import <func1>,<func2>... 语句是从模块中导入指定的函数, from <module> import * 则将模块中的所有方法都导入

导入一个模块时的路径搜索顺序如下:

  1. 先从当前目录查找是否有此模块
  2. 如果当前目录没有, 就从 PYTHONPATH 定义的目录下查找
  3. 如果都找不到, 就查看默认路径, linux 下一般是 /usr/lib/python

搜索路径定义在 sys.path 中, 可以用 append 函数来添加指定目录, 如项目中模块不再同一个目录就可以添加 path 来导入

包

python 中的包就是一个分层次的目录, 定义了一个由模块及子包组成的环境.

包简单来说就是一个目录, 目录中必须包含一个 __init__.py, 该文件可以为空, 目的使用来标识这个目录是一个包, 一个简单的例子如下:

如存在目录 package_test , 此目录下有 __init__.py, foo1.py, foo2.py 等文件

foo1.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo1():
    print("Foo1 test")

foo2.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo2():
    print("Foo2 test")

调用:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from package_test.foo1 import foo1
from package_test.foo2 import foo2

if __name__ == "__main__":
    foo1()
    foo2()

类

python 是一门面向对象语言, 所以创建类和对象是很容易的, 先简单介绍下面向对象的一些基本特征:

类的创建

python 中类创建的语法如下:

# 创建一个类
class Human:
    # 类变量
    var1 = 0 # 公有成员
    _var2 = 0 # 受保护成员
    __var3 = 0 # 私有成员

    # 构造函数, 里面可以定义实例变量, 这些变量只有在这个函数调用后才能使用, 子类如果重写了构造函数, 则不能使用这些变量
    def __init__(self, arg1, arg2...):
        self.arg1 = arg1
        self._arg2 = arg2
        self.__arg3 = arg3

    # 类方法
    def foo(self):
        print("Var1:", var1)
        print("Arg1:", self.arg1)

"""
动态类型的语言在创建实例后, 可以给实例绑定任何的属性和方法, 但这些绑定只对当前实例有效
如果要对所以实例生效, 可以在创建实例前给动态的给类绑定
"""

# 动态的给类绑定属性和方法, 这些属性和方法所有实例都可用
Human.school = ''
# 实例化
h = Human(arg1, arg2...)
print(h.school)
# 方法调用
h.foo()
# 动态的给实例绑定属性和方法, 这些属性和方法只能该实例可用
h.parent = 'Big Joy'
# 类的销毁
del h

类的实例化是通过调用构造函数完成的, __init__ 函数中定义了实例化时需要的参数.

类中以一个 _ 开头命令的变量或方法叫做受保护成员, 以二个 _ 开头命名的叫做私有成员, 以 __ 开头并以 __ 结尾的为系统定义的, 一般是内置的成员.

使用 del 则可销毁一个类实例.

类内置了以下属性:

类的继承

语法如下:

class SubName(Parent1, Parent2...):
    pass

一个子类可以继承多个父类, 使用 isintance(obj, type) 可以判断一个对象的类型, 使用 issubclass(sub, parent) 可以判断是否为另一个类的子类.

方法重写

如果父类的方法不能满足子类的需求, 子类就可重写此方法, 在使用子类对象调用此方法时会调用重写后的方法.

运算符重载 也是方法的重写, 只不过是对一些内置方法进行重写.

下面列出一些基本的内置方法:

更多的内置方法请查阅手册

以上就介绍完了 python 的基础知识, 按照上面的内容就能够写出 python 程序了, 当然前提是你不是一个小白, 至少熟悉一门编程语言.

但 python 还有很多高级知识则需要你自行使用学习了, 如文件操作, 进程和线程, 网络编程, 图形编程等等. 本文的目的只是让你明白 python 程序应该怎么写, 怎么把你用其他语言写的程序转换成 python 语言的, 更多高级的特性只能靠你自己学习尝试.

上一篇下一篇

猜你喜欢

热点阅读