Python入门笔记1

about python
特点：优雅简约
优点：
1.首选是网络应用，包括网站、后台服务等等；
2.其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
3.另外就是把其他语言开发的程序再包装起来，方便使用。
缺点：

1. 运行速度慢（解释型语言）
2. 不能加密

哈哈严谨老廖

一、基础

1.0有趣的小入门

import this # python的一些理念

import keyword
keyword.kwlist #列出关键字，当前版本下可用的所有关键字

python之禅翻译

   >>>import this
    The Zen of Python, by Tim Peters
    #Python之道 Tim Peters
    Beautiful is better than ugly.
    #美好胜于丑陋
    Explicit is better than implicit.
    #清楚胜于含混
    Simple is better than complex.
    #简明胜于复杂
    Complex is better than complicated.
    #复杂胜于晦涩
    Flat is better than nested.
    #平直胜于曲折
    Sparse is better than dense.
    #疏散胜于密集
    Readability counts.
    #重在易读
    Special cases aren't special enough to break the rules.
    #遵守规则,概莫能外
    Although practicality beats purity.
    #纵然实践会击败真理
    Errors should never pass silently.
    #错误却万不容姑息
    Unless explicitly silenced.
    #除非心意已冷
    In the face of ambiguity, refuse the temptation to guess.2
    #疑窦丛生,拒绝猜测
    There should be one-- and preferably only one --obvious way to do it.
    #宁折不弯,探寻正道
    Although that way may not be obvious at first unless you're Dutch.
    #路漫漫其修远兮,吾将上下而求索
    Now is better than never.
    #悟以往之不谏,知来者之可追
    Although never is often better than *right* now.
    #前路不明,似应放弃
    If the implementation is hard to explain, it's a bad idea.
    #晦涩难懂,弃之可也
    If the implementation is easy to explain, it may be a good idea.
    #简明易懂,方可存留
    Namespaces are one honking great idea -- let's do more of those!
    #命名空间,多多益善 

1.1自动生成注释

防止中文乱码
当前时间
名字
编译器
注意： 区分大小写

#-*- codeing = utf-8 -*-
#@Time : ${DATE} ${TIME}
#@Author : Scarlett
#@File : ${NAME}.py
#@Software : ${PRODUCT_NAME}

1.2注释

# 我是单行注释
'''
我
是
多行注释
'''

1.3格式化输出

1.4算术运算符

以a = 10, b = 21为例

#//也有一个好玩的名，叫地板除

1.5数据类型和变量

‘’‘…’''的格式表示多行内容

变量

python 是弱类型语言，相对于强类型语言，它不需要声明变量的类型。

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言

变量范围

Python的整数没有大小限制
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）

字符串

在字符串前加r，表示直接显示，不进行转义

字符串的常用操作

list vs tuple

list列表

1. Python内置的一种数据类型

2. list是一个可变的有序表

3. 索引从0开始
   

4. 列表名.append('内容') 往list中追加元素到末尾，作为整体加入

列表名.insert(n,'内容')

把元素插入到索引为n处

列表名.expend(内容)

拆开，每部分依次加入

列表名.pop()

删除list末尾的元素

列表名.pop(i)

删除list索引为i的元素

列表名.remove("内容")

删除首次出现的该内容

简单应用

products = [["iphone", 6888], ["MacPro", 14800], ["小米", 2499], ["Coffee", 31],
            ["Book", 60], ["Nike", 699]]
id = input()
a = []
while id != 'q':
    a.append(products[int(id)][0])
    id = input()
print(a)

tuple

[tjʊpəl; ˈtʌpəl](ta二声pao一声

• tuple一旦初始化就不能修改，但可以包含可变对象，eg list
• 如果tuple只有一个元素，必须加逗号

t1 = (1, [2, 3])
t2 = ('a',)

disc

set集合

可用于去重

常用操作

四种比较

1.6条件判断

以猜拳游戏为例

import random

finger1 = random.randint(0,2);
finger2 = random.randint(0,2);
if finger1 == finger2 :
    print('打平')
    print('我能输吗')
elif finger1 == (finger2 + 1) % 3 :
    print('小甲赢了')
else :
    print('小乙赢了')

1.7循环判断

for循环

for i in range(0, 13, 3) : # 从0到12，步长为3，python中的范围通常是左闭右开的
    print(i, end = "\t")
print();
s = 'tomorrow'
for x in s :
    print(x, end = ' ')
print();
a = ["aa", "bb", "cc"]
for x in range(len(a)):
    print(x, a[x])

while循环

以从1到100求和为例

n = 1
sum = 0
while n < 101 :
    sum += n
    n += 1
else :
    print("计算完毕啦")
print(sum)

1.8文件操作

访问模式

open(文件名，访问模式)

rename(文件名， 新的文件名) 重命名

1.9异常

try:
    print(0)
    f = open("test.txt", "r")
    try:
        print(t)
        print(1)
    finally:
        f.close()
        print("close file")
except (NameError, IOError) as result:
    print(result)

简单应用之拷贝古诗

f = open("poem.txt", "w", encoding = 'utf-8')
f.write('''
    岱宗夫如何，齐鲁青未了。 
    造化钟神秀，阴阳割昏晓。 
    荡胸生曾云，决眦入归鸟。 
    会当凌绝顶，一览众山小。 
''')
f.close()

f = open("poem.txt", "r", encoding = 'utf-8')
c = open("copy.txt", "w", encoding = 'utf-8')
content = f.readlines()
for x in content :
    c.write(x)
f.close()
c.close()

二、进阶

2.1 函数

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

调用内置函数&定义函数

• 内置函数
  Python内置了很多有用的函数，我们可以直接调用.
  常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数。

print(int(1.2345)) # 1

hex()函数把一个整数转换成十六进制表示的字符串

n1 = 255
n2 = 1000
print(hex(n1), hex(n2)) # 0xff 0x3e8

• 定义函数
  在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回
  • 空函数
    如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass还可以用在其他语句里，比如：

if(age > 35):
	pass

缺少了pass，代码运行就会有语法错误

• 返回多个值

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

• 简单应用

def quadratic(a, b, c):
    temp = b * b - 4 * a * c
    if(temp < 0):
        return None
    if temp == 0:
        x1 = -b / (2 * a)
        return x1, x1
    else:
        x1 = (-b + temp ** 0.5) / (2 * a)
        x2 = (-b - math.sqrt(temp)) / (2 * a)
        return x1, x2

# 测试:
print('quadratic(2, 3, 1) =', quadratic(2, 3, 1))
print('quadratic(1, 3, -4) =', quadratic(1, 3, -4))

if quadratic(2, 3, 1) != (-0.5, -1.0):
    print('测试失败')
elif quadratic(1, 3, -4) != (1.0, -4.0):
    print('测试失败')
else:
    print('测试成功')

参数

• 默认参数
  若不传入默认参数，则为默认值；若传入明确参数，则为传入值
  设置默认参数时，有几点要注意：
  一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
  二是如何设置默认参数。
  当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
  使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

def power(n, x = 2):
    ans = 1
    while x > 0:
        ans *= n
        x -= 1
    return ans

print(power(2)) # 4
print(power(2, 3)) # 8

• 可变参数
  在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
  定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。
  在list或tuple前面加一个 *号，把list或tuple的元素变成可变参数传进去

def sum(*nums):
    ans = 0
    for num in nums:
        ans += num
    return ans

a = [1, 2, 3, 4, 5]
print(sum(*a)) # 15
print(sum()) # 0
print(sum(1)) # 1

• 关键字参数
  关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

# 函数person除了必选参数name和age外，还接受关键字参数info
def person(name, age, **info):
    print('name:', name, 'age:', age, 'info:', info)

# 在调用该函数时，可以只传入必选参数
# name: mary age: 18 info: {}
person('mary', 18) 

# 也可以传入任意个数的关键字参数
# name: rick age: 81 info: {'feature': 'smart', 'ability': 120}
person('rick', 81, feature = 'smart', ability = 120) 

关键字参数可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去

extra = {'hobby': 'Jessica', 'grade':'3'}
#name: morty age: 16 info: {'hobby': 'Jessica', 'grade': '3'}
person('morty', 16, hobby = extra['hobby'], grade = extra['grade'])

简化版

extra = {'hobby': 'Jessica', 'grade':'3'}
person('morty', 16, **extra) #name: morty age: 16 info: {'hobby': 'Jessica', 'grade': '3'}

** extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**info参数，info将获得一个dict，注意info获得的dict是extra的一份拷贝，对info的改动不会影响到函数外的extra

• 命名关键字参数
  如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。
  和关键字参数**info不同，命名关键字参数需要一个特殊分隔符*，* 后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

#summer 17 New York coder
person('summer', 17, city = 'New York', job = 'coder')

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

#summer 17 () New York coder
person('summer', 17, city = 'New York', job = 'coder')

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
由于调用时缺少参数名city和job，Python解释器把前两个参数视为位置参数，后两个参数传给*args，但缺少命名关键字参数导致报错。
命名关键字参数可以有缺省值(默认值)，从而简化调用

def person(name, age, *args, city = 'New York', job):
    print(name, age, args, city, job)

#summer 17 () New York coder
person('summer', 17, job = 'coder')

def person(name, age, *args, city = 'New York', job):
    print(name, age, args, city, job)

#summer 17 () TieLing coder
person('summer', 17, city = 'TieLing', job = 'coder')

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

• 参数组合
  在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def person(name, age, hobby = 'learning', ** info):
    print(name, age, hobby, info)

#beth 32 learning {'job': 'doctor', 'ability': '105'}
person('beth', 32, job = 'doctor', ability = '105')

def person(name, age, hobby = 'learning', *, city, **info):
    print(name, age, hobby, city, info)

#jerry 35 learning Paris {'ability': 0}
person('jerry', 35, city = 'Paris', ability = 0)

最神奇的是通过一个tuple和dict，你也可以调用上述函数

def person(name, age, hobby = 'learning', *, city, **info):
    print(name, age, hobby, city, info)

#jerry 35 learning Paris {'ability': 0}
need = ('jerry', 35)
optional ={'city':'Paris', 'ability':0}
person(*need, **optional)

• 简单应用
  以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积

def mul(x, *y):
    ans = x
    for k in y:
        ans *= k
    return ans