Python基础学习笔记（一）

安装python可以去官网下载安装包，各个系统安装步骤可以自行搜索。

记录python中常用语法：

一、

print：

字符串用'' 或者""

print('hello')
print("hello")

连接字符串用+

二、运算

直接在运行台上用 加减乘除+-*/

int() 和 float()；当int()一个浮点型数时，int会保留整数部分,比如 int(1.9),会输出1,而不是四舍五入。

次方**

3**2  #3的2次方，等于9

取余数%

8%3  #8除以3等于2余2，结果是2

定义变量，直接赋值，不用申明类型，可以一次性定义多个变量

apple=1
a,b,c,d=1,2,3,4

三、

while循环

while condition:
    expressions

例：打印出0-9的所有数据

condition = 0
while condition < 10:
    print(condition)
    condition = condition + 1

四、

for循环

for item in sequence:
    expressions

例：内容依次为 example_list 中的每一个元素 注意 Python 是使用缩进表示程序的结构

example_list = [1,2,3,4,5,6,7,12,543,876,12,3,2,5]
for i in example_list:
    print(i)

五、

range使用

在 Python 内置了工厂函数，range 函数将会返回一个序列，总共有三种使用方法

1 range(start, stop)

其中 start 将会是序列的起始值，stop为结束值，但是不包括该值，类似 数学中的表达 [start, stop),左边为闭区间，右边为开区间。

for i in range(1, 10):
    print(i)

上述表达将会返回 1-9 所有整数，但不包含 10

2 range(stop)

如果省略了 start 那么将从 0 开始，相当于 range(0, stop)

3 range(start, stop, step)

step 代表的为步长，即相隔的两个值得差值。从 start 开始，依次增加 step 的值，直至等于或者大于 stop

for i in range(0,10, 5):
    print(i)

将会输出 0, 5。

六、

在 Python 中集合类型有 list、 tuple 、dict 和 set 等

list是用中括号来命名的：

a_list = [12, 3, 67, 7, 82]

功能：

#append()添加
a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最后面追加一个0
print(a)
# [1, 2, 3, 4, 1, 1, -1, 0]


#insert()指定位置添加
a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1处添加0
print(a)
# [1, 0, 2, 3, 4, 1, 1, -1]


#remove移除
a = [1,2,3,4,1,1,-1]
a.remove(2) # 删除列表中第一个出现的值为2的项
print(a)
# [1, 3, 4, 1, 1, -1]


#索引
#显示特定位：
a = [1,2,3,4,1,1,-1]
print(a[0])  # 显示列表a的第0位的值
# 1

print(a[-1]) # 显示列表a的最末位的值
# -1

print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
# [1, 2, 3]

print(a[5:])  # 显示列表a的第5位及以后的所有项的值
# [1, -1]

print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
# [1, 1, -1]


#打印列表中的某个值的索引(index):
a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
# 1

#统计列表中某值出现的次数：
a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
# 1



#对列表的项排序：
a = [4,1,2,3,4,1,1,-1]
a.sort() # 默认从小到大排序
print(a)
# [-1, 1, 1, 1, 2, 3, 4, 4]

a.sort(reverse=True) # 从大到小排序
print(a)
# [4, 4, 3, 2, 1, 1, 1, -1]

tuple 类型：可以用小括号、或者无括号来表述

tup = ('python', 2.7, 64)
for i in tup:
    print(i)

程序将以此按行输出 ‘python’, 2.7 和 64。

dictionary 类型（相当于c++/java里面的map）

数字和字符串都可以当做key或者value， 在同一个字典中, 并不需要所有的key或value有相同的形式。

dic = {}
dic['lan'] = 'python'
dic['version'] = 2.7
dic['platform'] = 64
for key in dic:
    print(key, dic[key])

输出的结果为：platform 64，lan python, version 2.7, 字典在迭代的过程 中将 key 作为可迭代的对象返回。注意字典中 key 是乱序的，也就是说和插入 的顺序是不一致的。如果想要使用顺序一致的字典，请使用 collections 模块 中的 OrderedDict 对象。

set 类型

s = set(['python', 'python2', 'python3','python'])
for item in s:
    print(item)

将会输出 python, python3, python2 set 集合将会去除重复项，注意输出的 结果也不是按照输入的顺序。

添加某个元素用add

清除元素用remove或者discard，清除全部用clear

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']

unique_char = set(char_list)   # {'b', 'd', 'a', 'c'}
unique_char.add('x')
# unique_char.add(['y', 'z']) this is wrong
print(unique_char)  # {'x', 'b', 'd', 'c', 'a'}

unique_char.remove('x')
print(unique_char)  # {'b', 'd', 'c', 'a'}

unique_char.discard('d')
print(unique_char)  # {'b', 'c', 'a'}

unique_char.clear()
print(unique_char)   # set()

set的筛选操作

我们还能进行一些筛选操作, 比如对比另一个东西, 看看原来的 set 里有没有和他不同的 (difference). 或者对比另一个东西, 看看 set 里有没有相同的 (intersection).

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)  

 # {'b', 'd', 'a', 'c'}

print(unique_char.difference({'a', 'e', 'i'}))# {'b', 'd', 'c'}print(unique_char.intersection({'a', 'e', 'i'}))# {'a'}

七、

迭代器

Python 中的 for 句法实际上实现了设计模式中的迭代器模式 ，所以我们自己也可以按照迭代器的要求自己生成迭代器对象，以便在 for 语句中使用。 只要类中实现了 __iter__和 next 函数，那么对象就可以在 for 语句中使用。 现在创建 Fibonacci 迭代器对象,

# define a Fib class
class Fib(object):
    def __init__(self, max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise StopIteration()

# using Fib object
for i in Fib(5):
    print(i)

将会输出前 5 个 Fibonacci 数据 1，1, 2, 3, 5

八、

生成器

除了使用迭代器以外，Python 使用 yield 关键字也能实现类似迭代的效果，yield 语句每次 执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。这样做的 好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次。

def fib(max):
    a, b = 0, 1
    while max:
        r = b
        a, b = b, a+b
        max -= 1
        yield r

# using generator
for i in fib(5):
    print(i)

将会输出前 5 个 Fibonacci 数据 1，1, 2, 3, 5

(有个缺点是当调用fib(0)的时候，yield是没有数据的，所以fib(0)没有返回值)

九、

1.  if判断

if condition:
    expressions

例：

x = 1
y = 2
z = 3
if x < y:
    print('x is less than y')

2. if else 判断

基本使用 
if condition:
    true_expressions
else:
    false_expressions

例：

x = 1
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal to y')

python 中并没有类似 condition ? value1 : value2 三目操作符。但python 可以通过 if-else 的行内表达式完成类似的功能。

var = var1 if condition else var2

可以这么理解上面这段语句，如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var。

worked = True
result = 'done' if worked else 'not yet'
print(result)

首先判断如果 work 为 True,那么将 done 字符串赋给 result，否则将 not yet 赋给 result。 结果将输出 done。

3.   if elif else 判断

基本使用 ¶
if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

十、def 函数

基本使用 
def function_name(parameters):
    expressions

Python 使用 def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的 具体功能实现代码，如果想要函数有返回值, 在 expressions 中的逻辑代码中用 return 返回。

parameters的位置就是函数的参数（也可以没有参数），在调用的时候传入即可。

例：

def function():
    print('This is a function')
    a = 1+2
    print(a)

上面我们定义了一个名字为 function 的函数，函数没有接收参数，所以括号内部为空，紧接着就是 函数的功能代码。如果执行该脚本，发现并没有输出任何输出，因为我们只定义了函数，而并没有执行函数。 这时我们在 Python 命令提示符中输入函数调用 function(), 注意这里调用函数的括号不能省略。那么 函数内部的功能代码将会执行，输出结果：

This is a function
3

如果我们想要在脚本中调用的脚本，只需要在脚本中最后添加函数调用语句

function()

那么在执行脚本的时候，将会执行函数。

加参数：

def func(a, b):
    c = a+b
    print('the c is ', c)

函数默认参数：

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
    expressions

例：

def sale_car(price, color='red', brand='carmy', is_second_hand=True):
    print('price', price,
          'color', color,
          'brand', brand,
          'is_second_hand', is_second_hand,)

自调用

如果想要在执行脚本的时候执行一些代码，比如单元测试，可以在脚本最后加上单元测试 代码，但是该脚本作为一个模块对外提供功能的时候单元测试代码也会执行，这些往往我们不想要的，我们可以把这些代码放入脚本最后：

if __name__ == '__main__':
    #code_here

如果执行该脚本的时候，该 if 判断语句将会是 True,那么内部的代码将会执行。 如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行。

 可变参数

顾名思义，函数的可变参数是传入的参数可以变化的，1个，2个到任意个。当然可以将这些 参数封装成一个 list 或者 tuple 传入，但不够 pythonic。使用可变参数可以很好解决该问题，注意可变参数在函数定义不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数。

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    print(name, 'total grade is ', total_grade)

定义了一个函数，传入一个参数为 name, 后面的参数 *grades 使用了 * 修饰，表明该参数是一个可变参数，这是一个可迭代的对象。该函数输入姓名和各科的成绩，输出姓名和总共成绩。所以可以这样调用函数 report('Mike', 8, 9)，输出的结果为 Mike total grade is 17, 也可以这样调用 report('Mike', 8, 9, 10)，输出的结果为 Mike total grade is 27

关键字参数

关键字参数可以传入0个或者任意个含参数名的参数，这些参数名在函数定义中并没有出现，这些参数在函数内部自动封装成一个字典(dict).

def portrait(name, **kw):
    print('name is', name)
    for k,v in kw.items():
        print(k, v)

定义了一个函数，传入一个参数 name, 和关键字参数 kw，使用了 ** 修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。如果调用参数portrait('Mike', age=24, country='China', education='bachelor') 输出:

name is Mike
age 24
country China
education bachelor

通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达。