python复习笔记

import turtle

turtle.pensize(4)
turtle.pencolor('red')
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.mainloop()

a=100
b=12.345
c=1+3j
d='hello world'
e=True
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bool'>

int()：将一个数值或字符串转换成整数，可以指定进制。

float()：将一个字符串转换成浮点数。

str()：将指定的对象转换成字符串形式，可以指定编码。

chr()：将整数转换成该编码对应的字符串（一个字符）。

ord()：将字符串（一个字符）转换成对应的编码（整数）。

list():将元组转换成列表

tuple():将列表转换为元组

set():返回一个集合

运算符	描述
[] [:]	下标，切片
**	指数
~ + -	按位取反, 正负号
* / % //	乘，除，模，整除
+ -	加，减
>> <<	右移，左移
&	按位与
^	按位异或，按位或
<= < > >=	小于等于，小于，大于，大于等于
== !=	等于，不等于
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符
= += -= *= /= %= //= **= &= \|= ^= >>= <<=	（复合）赋值运算符

range(100) 0 - 99

range(1,100) 1 - 99

range(1,100,2) 1 - 99间的整数

print('*', end='') 不换行的print

\或()进行行之间代码的连接

def add(a=0, b=0, c=0):函数重载

在参数名前面的*表示args是一个可变参数

即在调用add函数时可以传入0个或多个参数

def add(*args):

Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的函数

__name__是Python中一个隐含的变量它代表了模块的名字
只有被Python解释器直接执行的模块的名字才是__main__

Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索

#str
def main():
    str1 = 'hello, world!'
    # 通过len函数计算字符串的长度
    print(len(str1))  # 13
    # 获得字符串首字母大写的拷贝
    print(str1.capitalize())  # Hello, world!
    # 获得字符串变大写后的拷贝
    print(str1.upper())  # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 与find类似但找不到子串时会引发异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith('!'))  # True
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50, '*'))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 从字符串中取出指定位置的字符(下标运算)
    print(str2[2])  # c
    # 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 检查字符串是否由数字构成
    print(str2.isdigit())  # False
    # 检查字符串是否以字母构成
    print(str2.isalpha())  # False
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 获得字符串修剪左右两侧空格的拷贝
    print(str3.strip())


if __name__ == '__main__':
    main()

13
Hello, world!
HELLO, WORLD!
8
-1
False
True
True
******************hello, world!*******************
                                     hello, world!
c
c12
c123456
c246
ac246
654321cba
45
False
False
True
  jackfrued@126.com 
jackfrued@126.com

python的后一个操作数总是不取,像range(1,2),[1,4]像是[1,2),[1,4)

str.title()是所有单词首字母大写,str.capitalize()是首字母大写

#list
def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 计算列表长度(元素个数)
    print(len(list1))
    # 下标(索引)运算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    print(list1[-1])
    print(list1[-3])
    list1[2] = 300
    print(list1)
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    list1 += [1000, 2000]
    print(list1)
    print(len(list1))
    # 删除元素
    list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)


if __name__ == '__main__':
    main()

[1, 3, 5, 7, 100]
['hello', 'hello', 'hello', 'hello', 'hello']
5
1
100
100
5
[1, 3, 300, 7, 100]
[1, 400, 3, 300, 7, 100, 200, 1000, 2000]
9
[400, 300, 7, 100, 200, 1000, 2000]
[]

list.insert()前面是位置(index)(从零开始)，后面是对象,append在后面加,+=一个list对象也是在后面

remove()删掉参数的第一个出现,del list[0]删掉了列表里的第0个元素

def main():
    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
    fruits += ['pitaya', 'pear', 'mango']
    # 循环遍历列表元素
    for fruit in fruits:
        print(fruit.title(), end=' ')
    print()
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2)
    # fruit3 = fruits  # 没有复制列表只创建了新的引用
    # 可以通过完整切片操作来复制列表
    fruits3 = fruits[:]
    print(fruits3)
    fruits4 = fruits[-3:-1]
    print(fruits4)
    # 可以通过反向切片操作来获得倒转后的列表的拷贝
    fruits5 = fruits[::-1]
    print(fruits5)


if __name__ == '__main__':
    main()

Grape Apple Strawberry Waxberry Pitaya Pear Mango 
['apple', 'strawberry', 'waxberry']
['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
['pitaya', 'pear']
['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

切片后得到的是原来的对象的拷贝,而单纯的复制是将指针复制,没有拷贝,像是fruits=fruit是别名,地址相同,可以通过id()查看

def main():
    list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list2 = sorted(list1)
    # sorted函数返回列表排序后的拷贝不会修改传入的列表
    # 函数的设计就应该像sorted函数一样尽可能不产生副作用
    list3 = sorted(list1, reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list4 = sorted(list1, key=len)
    print(list1)
    print(list2)
    print(list3)
    print(list4)
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list1)


if __name__ == '__main__':
    main()
#我们还可以使用列表的生成式语法来创建列表，代码如下所示。

import sys


def main():
    f = [x for x in range(1, 10)]
    print(f)
    f = [x + y for x in 'ABCDE' for y in '1234567']
    print(f)
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    f = [x ** 2 for x in range(1, 1000)]
    print(sys.getsizeof(f))  # 查看对象占用内存的字节数
    print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    f = (x ** 2 for x in range(1, 1000))
    print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
    print(f)
    for val in f:
        print(val)


if __name__ == '__main__':
    main()

sorted()返回一个新的列表对象,要求传入的对象可迭代,reverse参数表示返回的列表是否要反转一下,也就是默认的是左小右大,reverse=True后为左大右小,key用来指定排序的标准,字符串默认为字典序

list.sort()是list的方法,也有key和reverse的flag,是直接在list对象上排

列表的生成表达式f = [x + y for x in 'ABCDE' for y in '1234567']要求in后面是可迭代的对象,创建了一个列表容器
f = (x ** 2 for x in range(1, 1000))生成器对象,时间换空间的体现
for迭达是通过不停的使用next()方法实现的

生成器函数:通过yield关键字将一个普通函数改造为生成器函数

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a


def main():
    for val in fib(20):
        print(val)


if __name__ == '__main__':
    main()

他遇到next调用时执行,执行到yield返回,下一次从yield开始执行

sys.getsizeof(<class>)可以查看对象的大小

def main():
    # 定义元组
    t = ('骆昊', 38, True, '四川成都')
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '王大锤'  # TypeError
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('王大锤', 20, True, '云南昆明')
    print(t)
    # 将元组转换成列表
    person = list(t)
    print(person)
    # 列表是可以修改它的元素的
    person[0] = '李小龙'
    person[1] = 25
    print(person)
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)


if __name__ == '__main__':
    main()

元组不可修改

tuple和list返回的都是不同的对象了

#集合
def main():
    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)
    print('Length =', len(set1))
    set2 = set(range(1, 10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11, 12])
    print(set1)
    print(set2)
    set2.discard(5)
    # remove的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())
    print(set3)
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判断子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))


if __name__ == '__main__':
    main()

{1, 2, 3}
Length = 3
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
{1, 2, 3, 6, 7, 8, 9, 11, 12}
1 4 9 36 49 64 81 121 144 
1
{2, 3}
{1, 2, 3}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
{4, 5}
{4, 5, 6, 7, 8, 9, 11, 12}
False
True
False
True

set是无序的，所以不会有重合的元素

set.add()将整个参数作为set的一员传入

set1.add((12,14))#{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, (12, 14)}

set.update()将参数内的元素传入,参数可为元组或列表或表达式(可迭代)

set.discard()将参数删掉了,没有不报错
set.remove()没有的话要报错
&,|，-，^交,并,差,对称差set.intersection(),set.union(),set.difference(),set.symmetric_difference()
$$a\cap b,a\cup b,a-b,(a\cup b)-(a\cap b)$$

set.pop()从set中任意弹出一个元素(似乎是从右弹到左)

<=子集set.issubset(),>=超集set.isupset()

def main():
    scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
    # 通过键可以获取字典中对应的值
    print(scores['骆昊'])
    print(scores['狄仁杰'])
    # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
    for elem in scores:
        print('%s\t--->\t%d' % (elem, scores[elem]))
    # 更新字典中的元素
    scores['白元芳'] = 65
    scores['诸葛王朗'] = 71
    scores.update(冷面=67, 方启鹤=85)
    print(scores)
    if '武则天' in scores:
        print(scores['武则天'])
    print(scores.get('武则天'))
    # get方法也是通过键获取对应的值但是可以设置默认值
    print(scores.get('武则天', 60))
    # 删除字典中的元素
    print(scores.popitem())
    print(scores.popitem())
    print(scores.pop('骆昊', 100))
    # 清空字典
    scores.clear()
    print(scores)


if __name__ == '__main__':
    main()

95
82
骆昊	--->	95
白元芳	--->	78
狄仁杰	--->	82
{'骆昊': 95, '白元芳': 65, '狄仁杰': 82, '诸葛王朗': 71, '冷面': 67, '方启鹤': 85}
None
60
('方启鹤', 85)
('冷面', 67)
95
{}

dict.popitem()弹出一个元素作为二元组,dict.pop(k[,v])弹出特定键值并返回键值k对应的值,没有的话返回v,dict.get(k[,v])类似pop

os.system(<cmd>)可以执行shell命令

time.sleep()单位是s

import os
import time


def main():
    content = '北京欢迎你为你开天辟地…………'
    while True:
        # 清理屏幕上的输出
        os.system('clear')  # os.system('clear')
        print(content)
        # 休眠200毫秒
        time.sleep(0.2)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()