python3 基础-CSDN博客

●if __name__ == '__main__':表示程序执行的入口(如c中的main)Python本身并没有这么规定，这只是一种编码习惯。由于模块之间相互引用，不同模块可能有这样的定义，而程序入口只有一个。到底哪个程序入口被选中，这取决于__name__的值。_name__是内置变量，可用于表示当前模块的名字

●input("提示消息，可加可不加") --从终端接收数据

●print() 输出数据

print("...{}".format(变量),end="x") 格式化输出数据，如：print('{:.10f} {}'.format(x,y)),以保留10个小数点的格式输出x,直接输出y

end=“x”代表每个元素以x结尾,详情自查

●字符串若是乘上整数 n，将返回由 n 个此字符串拼接起来的新字符串,例: 's' * 10 等于'ssssssssss'

数据结构/常用函数

列表list,可用作栈/队列

声明，如:a=[1,2,3]

主要函数:

append(x):将x添加到尾部
insert(index,x):将x插入到索引index处
count(x):返回x出现的次数
remove(x):移除x
pop(index):将索引index处的元素弹出
reverse():翻转列表
extend(b):将列表b添加到列表结尾
sort():排序
可使用del关键字删除指定位置的列表元素。如del a[0]

列表推导式:一种列表推导的简写方式,列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成，如：squares = [x**2 for x in range(10)]

切片:返回列表某个范围内的列表，即访问某段内的元素，如a[:3]

翻转:a[::-1]

元组tuple

元素不可变的列表

声明，如 a=(1,2,3)或者,a=1,2,3

这样声明就是元组，编辑元组元素会报错

集合set

集合是一个无序不重复元素的集。

声明,如a={1,2,3},或者a=set()（即创建一个集合），可以传参数，该参数为初始列表，如a = set('ab')为{a,b}

如果想要创建空集合，必须使用 set() 而不是 {}。后者用于创建空字典。

交并差& | - a^b:存在于a或b但不能同时存在

字典dictionary

字典是是无序的键值对（key:value）集合。

声明,如a={1:2,2:3}

items():用于迭代字典,返回为(x,y),类型为class dict_items

字符串string
声明 s=""
如果你想要分几行输入字符串，并且希望行尾的换行符自动包含到字符串当中，可以使用三对引号："""\...""" 或 '''\...''' 。
string有各种内置方法

title() 返回字符串的标题版本，即单词首字母大写其余字母小写
upper() 返回字符串全部大写的版本
upper() 返回字符串全部大写的版本
swapcase() 返回字符串大小写交换后的版本
isalnum() 检查所有字符是否只有字母和数字
isalpha() 检查字符串之中是否只有字母
split() 分割任意字符串，split() 允许有一个参数，用来指定字符串以什么字符分隔（默认为 " "），它返回一个包含所有分割后的字符串的列表。
join(list) 使用指定字符连接多个字符串，将列表list中的元素用该字符串连接起来
strip(chars)，用来剥离字符串首尾中指定的字符，默认为" ",剥离规则为按chars中的char顺序寻找该字符串，找到删除，若不指定参数，则效果为剥离首尾空格与换行符
lstrip(chars)) 只对字符串左剥离
rstrip(chars) 只对字符串右剥离。
find() 找到第一个匹配的子字符串，没有找到则返回 -1

通用函数:
type(a):返回a的类型
len(a): 返回 a的长度
range(a,b,c)：生成一个等差数列，非列表,a,b为范围，c为差值

函数

定义函数:
def 函数名(参数):
语句1
语句2
global关键字定义全局变量，即使在函数内部也可以定义
函数的参数变量可以有默认值:def test(a , b=-99):
可以接收一个函数作为参数,在函数内部使用参数函数，即高级函数

map(function,list):
map 是一个在 Python 里非常有用的高阶函数。它接受一个函数和一个序列（迭代器）作为输入，然后对序列（迭代器）的每一个值。返回一个序列（迭代器），其包含应用函数后的结果。
举例：
>>> lst = [1, 2, 3, 4, 5]
>>> def square(num):
... return num * num
>>> print(list(map(square, lst)))
[1, 4, 9, 16, 25]

可变参数 * args /关键字参数 ** kwargs(来源于:https://zhuanlan.zhihu.com/p/50804195)

在Python中的代码中经常会见到这两个词 args 和 kwargs，前面通常还会加上一个或者两个星号。其实这只是编程人员约定的变量名字，args 是 arguments 的缩写，表示位置参数；kwargs 是 keyword arguments 的缩写，表示关键字参数。这其实就是 Python 中可变参数的两种形式，并且 *args 必须放在 **kwargs 的前面，因为位置参数在关键字参数的前面。

*args

*args就是就是传递一个可变参数列表给函数实参，这个参数列表的数目未知，甚至长度可以为0。

def test_args(first, *args):
    print('Required argument: ', first)
    print(type(args))
    for v in args:
        print ('Optional argument: ', v)

test_args(1, 2, 3, 4)

第一个参数是必须要传入的参数，所以使用了第一个形参，而后面三个参数则作为可变参数列表传入了实参，并且是作为元组tuple来使用的。代码的运行结果如下

Required argument:  1
<class 'tuple'>
Optional argument:  2
Optional argument:  3
Optional argument:  4

**kwargs

而**kwargs则是将一个可变的关键字参数的字典传给函数实参，同样参数列表长度可以为0或为其他值。下面这段代码演示了如何使用kwargs

def test_kwargs(first, *args, **kwargs):
   print('Required argument: ', first)
   print(type(kwargs))
   for v in args:
      print ('Optional argument (args): ', v)
   for k, v in kwargs.items():
      print ('Optional argument %s (kwargs): %s' % (k, v))

test_kwargs(1, 2, 3, 4, k1=5, k2=6)

正如前面所说的，args类型是一个tuple，而kwargs则是一个字典dict，并且args只能位于kwargs的前面。代码的运行结果如下

Required argument:  1
<class 'dict'>
Optional argument (args):  2
Optional argument (args):  3
Optional argument (args):  4
Optional argument k2 (kwargs): 6
Optional argument k1 (kwargs): 5

调用函数

args和kwargs不仅可以在函数定义中使用，还可以在函数调用中使用。在调用时使用就相当于pack（打包）和unpack（解包），类似于元组的打包和解包。

首先来看一下使用args来解包调用函数的代码，

def test_args_kwargs(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

args = ("two", 3, 5)
test_args_kwargs(*args)

#result:
arg1: two
arg2: 3
arg3: 5

将元组解包后传给对应的实参，kwargs的用法与其类似。

kwargs = {"arg3": 3, "arg2": "two", "arg1": 5}
test_args_kwargs(**kwargs)

#result
arg1: 5
arg2: two
arg3: 3

args和kwargs组合起来可以传入任意的参数，这在参数未知的情况下是很有效的，同时加强了函数的可拓展性。

类

语法

class nameoftheclass(parent_class):
    statement

初始构造方法

def __init__(self):
    self.data = []

self即代表该类本身(类似于this),任何函数都可以传该参数该方法在构建类的实例时被执行，当然该方法可以传参，并使用self进行赋值

例:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

声明类实例

x=nameoftheclass()

继承

在class()中传一个class即代表继承于该类，通用父类为object

例:

#!/usr/bin/env python3

class Person(object):
    """
    返回具有给定名称的 Person 对象
    """

    def __init__(self, name):
        self.name = name

    def get_details(self):
        return self.name


class Student(Person):
    """
    返回 Student 对象，采用 name, branch, year 3 个参数
    """

    def __init__(self, name, branch, year):
        Person.__init__(self, name)
        self.branch = branch
        self.year = year

    def get_details(self):
        return "{} studies {} in {} year.".format(self.name, self.branch, self.year)

person1 = Person('x')
student1 = Student('y', 'CSE', 2045)

多继承

python支持多继承,在class()中传多个class即可

删除对象

使用关键字del可以删除实例对象

del 实际上使对象的引用计数减少一，当对象的引用计数变成零的时候，垃圾回收器会删除这个对象。

@property 装饰器

@property 装饰器，@property 装饰器就是负责把一个方法变成属性调用的。

说实话，这玩意让我想到了java的注解，在函数上使用该装饰器，可以把该函数当成属性来调用，返回值为一个property对象(实际上所有装饰器都返回一个函数或者对象，作用就是为指定函数/属性添加功能，即进行切面)

装饰器

装饰器的作用就是为函数增加功能(切面),@的写法相当于语法糖

def debug(func):
   def wrapper(*args, **kwargs):  # 变参
       print "[DEBUG]: enter {}()".format(func.__name__)               
       return func(*args, **kwargs)    
   return wrapper 

@debug
def say(something):
   print "hello {}!".format(something)

可以看到,debug为装饰器，实际上就是一个函数，内部包装一个函数，将函数say织入wrapper然后返回，在过程中完成了一些功能。

文件

使用 open() 函数打开文件，两个参数，第一个是文件路径，第二个是模式r/w/a(追加)
默认的模式为只读模式,返回一个文件(class)
close()：关闭文件
read()：一次性读取整个文件,read(size) 有一个可选的参数 size，用于指定字符串长度
readline() ：每次读取文件的一行
readlines() ：读取所有行到一个列表中。
使用for...in...循环遍历文件中的每一行
通过write() 方法写入文件，参数为内容

异常

使用 try...except 块来处理任意异常
try:
statements to be inside try clause
...
except ExceptionName:
statements to evaluated in case of ExceptionName happens
使用 raise 语句抛出一个异常
finally子句必定执行

模块

一个模块就是一个.py文件

导入模块

import xxx

from xxx import yyy,zzz

获取模块的名字

可以由全局变量__name__获取模块的名字

包

一个包包含了多个子模块，在一个目录下如果含有__init__.py文件，那么该目录就是一个包，__init__.py中的内容也有一些规则，声明列表__all__表明只有列表中的内容会被当做模块。

常用模块

os 模块提供了与操作系统相关的功能。
getuid() ：返回当前进程的有效用户 id。
getpid() ：返回当前进程的 id。g
etppid()：返回父进程的 id。
uname() ：返回识别操作系统的不同信息，在 Linux 中它返回的详细信息可以从 uname -a命令得到。uname() 返回的对象是一个元组，（sysname, nodename, release, version, machine）

>>> os.uname()
('Linux', 'd80', '2.6.34.7-56.fc13.i686.PAE', '#1 SMP Wed Sep 15 03:27:15 UTC 2010', 'i686')

getcwd() ：返回当前工作目录。
chdir(path)：更改当前目录到 path。

>>> os.getcwd()
'/home'
>>> os.chdir('Code')
>>> os.getcwd()
'/home/Code'

listdir(path):返回路径中的所有文件和路径

官网:https://docs.python.org/3/library/os.html

requests

一个第三方http库，用于进行网络编程

安装使用:sudo pip3 install requests

官网:https://2.python-requests.org//zh_CN/latest/