1. 首页
  2. 文章中心
  3. 胡乱写写

大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)

90 阅读 0 评论
我是靠谱客的博主 娇气哈密瓜，最近开发中收集的这篇文章主要介绍大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

类(class)

  1. 类的定义

    class nameoftheclass(parent_class):
statement1
statement2
statement3

  2. init 方法：将对象创建为有初始状态的

    >>> class Complex:
...
def __init__(self, realpart, imagpart):
...
self.r = realpart
...
self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
#创建了一个新的类实例并将该对象赋给局部变量
x
>>> x.r, x.i
(3.0, -4.5)

  3. 继承：

    1. 它将继承父类的所有功能（如变量和方法）

    2. 可以重写新方法

    3. 一个类可以继承自多个类，具有父类的所有变量和方法

      class MyClass(Parentclass1, Parentclass2,...):
def __init__(self):
Parentclass1.__init__(self)
Parentclass2.__init__(self)
...
...

    4. python3自动继承object类（如果为空）

  4. 删除对象

    del s

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

  5. 直接使用属性print(std.name)

Collections 模块

import collections

  1. Counter 对象:一个有助于 hashable 对象计数的 dict 子类

    1. elements() 的方法，其返回的序列中，依照计数重复元素相同次数，元素顺序是无序的

      >>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['b','b','a', 'a', 'a', 'a']

    2. most_common() 方法返回最常见的元素及其计数，顺序为最常见到最少

      >>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

    3. defaultdict :内建 dict 类的子类

元组（tuple)

元组的元素不能修改

  1. 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可a = 'Fedora', 'ShiYanLou', 'Kubuntu', 'Pardus' a = (1, 2, 3, 4)
  2. 元组封装data = ("shiyanlou", "China", "Python")
  3. 元组拆封 name, country, language = data

集合（set）

无序不重复元素

  1. 大括号或 set() 函数可以用来创建集合

  2. 空集合：使用 set() 而不是 {}，后者用于创建空字典

  3. 实例：

    创建去重+减法+|+&+^

    >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
# 你可以看到重复的元素被去除
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
>>> # 演示对两个单词中的字母进行集合操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
# a 去重后的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b
# a 有而 b 没有的字母
{'r', 'd', 'b'}
>>> a | b
# 存在于 a 或 b 的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b
# a 和 b 都有的字母
{'a', 'c'}
>>> a ^ b
# 存在于 a 或 b 但不同时存在的字母
{'r', 'd', 'b', 'm', 'z', 'l'}

    添加和弹出元素：

    >>> a = {'a','e','h','g'}
>>> a.pop()
# pop 方法随机删除一个元素并打印
'h'
>>> a.add('c')
>>> a
{'c', 'e', 'g', 'a'}

列表(list)

列表允许修改元素

  1. a = [ 1, 342, 223, ‘India’, ‘Fedora’]

  2. a[:]返回一个拷贝

  3. a[0:5] 用数学表达式可以写为 [0,5)

  4. a + [36, 49, 64, 81, 100]返回新列表

  5. letters[2:5] = ['C', 'D', 'E']赋值

  6. 查询'cool' in a

  7. 长度len(a)

  8. 是否为空if list_name:

  9. 函数

    1. a.append(45) 添加元素 45 到列表末尾
    2. a.insert(0, 1)在列表索引 0 位置添加元素 1
    3. a.count(45)返回列表元素中 s 的数量
    4. a.remove(234)在列表中移除任意指定值
    5. a.reverse()反转整个列表
    6. b = [45, 56, 90] a.extend(b) 添加 b 的元素而不是 b 本身
    7. a.sort()排序的前提是列表的元素是可比较的
    8. del a[-1]删除指定位置的列表元素

  10. 用作栈和队列

    1. a.pop()弹出末尾
    2. a.pop(0) 弹出列表中第一个元素

  11. 列表推导式

    1. squares = list(map(lambda x: x**2, range(10)))

    2. squares = [x**2 for x in range(10)]

    3. >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    4. 嵌套>>> a=[1,2,3] >>> z = [x + 1 for x in [x ** 2 for x in a]] >>> z [2, 5, 10]

字典(dict)

键值对：同一个字典内的键互不相同, 且是不可变类型（不能用列表做键）

  1. 创建字典

    >>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'}
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'}
>>> data['kart_']
'Debian'

  2. 创建新的键值对

    data['parthan'] = 'Ubuntu'

    不知道元素是否已经存在dict.setdefault(key, default)

    >>> data = {}
>>> data.setdefault('names', []).append('Ruby')
>>> data
{'names': ['Ruby']}
>>> data.setdefault('names', []).append('Python')
>>> data
{'names': ['Ruby', 'Python']}
>>> data.setdefault('names', []).append('C')
>>> data
{'names': ['Ruby', 'Python', 'C']}

    dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}
print "Value : %s" %
dict.setdefault('runoob', None)
print "Value : %s" %
dict.setdefault('Taobao', '淘宝')

  3. 删除任意指定的键值对

    del data['kushal']

  4. 查询指定的键是否存在于字典中

    'ShiYanLou' in data

  5. 从包含键值对的元组中创建字典

    >>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
{'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}

  6. 遍历一个字典items()

    for x, y in data.items():
print("{} uses {}".format(x, y))

  7. 返回指定键的值(不知道键存不存在),get()**

    dict.get(key, default=None) 如果键不在字典中返回默认值 None 或者设置的默认值

    >>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)
0

  8. 同时获得元素索引值enumerate()

    for i, j in enumerate(['a', 'b', 'c']):
print(i, j)

  9. 同时遍历两个序列类型zip()

    zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

    >>> a = ['Pradeepto', 'Kushal']
>>> b = ['OpenSUSE', 'Fedora']
>>> for x, y in zip(a, b):
...
print("{} uses {}".format(x, y))
...
Pradeepto uses OpenSUSE
Kushal uses Fedora

字符串

  1. 多行字符串 ：三引号

    >>> print("""
... Usage: thingy [OPTIONS]
...
-h
Display this usage message
...
-H hostname
Hostname to connect to
... """)
Usage: thingy [OPTIONS]
-h
Display this usage message
-H hostname
Hostname to connect to

  2. 大小写

    title() 返回字符串的标题版本,即单词首字母大写其余字母小写
upper() 返回字符串全部大写的版本
lower() 返回字符串的全部小写版本
swapcase() 返回字符串大小写交换后的版本
isalnum() 检查所有字符是否只有字母和数字
isalpha() 检查字符串之中是否只有字母

  3. x.split(':') 默认空格分隔，它返回一个包含所有分割后的字符串的列表

  4. "-".join("GNU/Linux is great".split()) 连接字符串join()，它需要一个包含字符串元素的列表作为输入，用 "-" 连接它们

  5. strip(chars)，用来剥离字符串首尾中指定的字符，默认为空格

    s.strip(“cwsd.”) #删除在字符串左边出现的’c’,‘w’,‘s’,‘d’,’.'字符

    lstrip(chars) 或 rstrip(chars) 只对字符串左或右剥离

  6. 字符串格式化:print(“Year {} Rs. {:.2f}”.format(year, value)) + end=" “, sep=” "

    其实是str.format()函数print("{}+to you{:.1f}".format(666,1.2365))

  7. 查找

    1. s.find(“for”)，找不到返回-1
    2. s.startswith(“fa”) 开头
    3. s.endswith(“reason”) 结尾

  8. 奇技淫巧

    1. z = s[::-1] 倒叙字符串
    2. x="*" * 5 print(x) 打印字符串

模块

  1. 你可以由全局变量 __name__ 得到模块的模块名（一个字符串）

     if __name__ == '__main__': 这条语句，它的作用是，只有在当前模块名为 __main__ 的时候（即作为脚本执行的时候）才会执行此 if 块内的语句。换句话说，当此文件以模块的形式导入到其它文件中时，if 块内的语句并不会执行

  2. import xxx as x

    from xxx import xxx

  3. 包

    1. 含有 __init__.py 文件的目录可以用来作为一个包，目录里的所有 .py 文件都是这个包的子模块

    2. 如果 __init__.py 文件内有一个名为 __all__ 的列表，那么只有在列表内列出的名字将会被公开。

      因此如果 mymodule 内的 __init__.py 文件含有以下内容：

      from mymodule.bars import simplebar
__all__ = [simplebar, ]

      那么导入时将只有 simplebar 可用。如果你在 python3 解释器中进行测试，需要确定是在 mymodule 目录同级的目录下执行的 python3，类似下面的操作，否则会出现 ImportError: No module named 'mymodule' 的报错。

    3. os 模块提供了与操作系统相关的功能

      1. getuid() 函数返回当前进程的有效用户 id
      2. getpid() 函数返回当前进程的 id。getppid() 返回父进程的 id。
      3. uname() 函数返回识别操作系统的不同信息，在 Linux 中它返回的详细信息可以从 uname -a 命令得到。uname() 返回的对象是一个元组，（sysname, nodename, release, version, machine）。
      4. getcwd() 函数返回当前工作目录。chdir(path) 则是更改当前目录到 path。

    4. Requests 模块

      使用 get() 方法获取任意一个网页
req = requests.get('https://github.com')
req.status_code

    5. argparse 模块帮你非常容易的编写用户友好的命令行接口

IO

  1. days = int(input("Enter days: "))

文件

  1. open() 函数：打开文件

    close()函数：关闭文件

    "r"，以只读模式打开，你只能读取文件但不能编辑/删除文件的任何内容
"w"，以写入模式打开，如果文件存在将会删除里面的所有内容，然后打开这个文件进行写入
"a"，以追加模式打开，写入到文件中的任何数据将自动添加到末尾
默认的模式为只读模式

  2. read() 方法一次性读取整个文件

    read(size) 有一个可选的参数 size，用于指定字符串长度

    >>> fobj = open("sample.txt")
>>> fobj.read()
'I love PythonnI love shiyanloun'
>>> fobj.close()

    readline() 能帮助你每次读取文件的一行

    readlines() 读取所有行到一个列表中

    循环遍历文件对象来读取文件中的每一行:↓

    >>> fobj = open('sample.txt')
>>> for x in fobj:
...
print(x, end = '')
...
I love Python
I love shiyanlou
>>> fobj.close()
for i,line in enumerate(fd):
spaces += line.count(' ')
tabs += line.count('t')

  3. write()文件写入 fobj.write(‘powerporkn’)

  4. 使用 with 语句

    使用 with 语句处理文件对象，它会在文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写：

    >>> with open('sample.txt') as fobj:
...
for line in fobj:
...
print(line, end = '')
...
I love Python
I love shiyanlou

函数

  1. 全局变量 global

  2. 默认参数值(没传值的时候默认):::函数重载 的功能大都可以使用默认参数达到

    1. 具有默认值的参数后面不能再有普通参数，比如 f(a,b=90,c) 就是错误的
    2. 默认值只被赋值一次，因此如果默认值是任何可变对象时会有所不同，比如列表、字典或大多数类的实例。例如，下面的函数在后续调用过程中会累积（前面）传给它的参数
    def test(a , b=-99):
return True

    >>> def f(a, data=[]):
...
data.append(a)
...
return data
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]

    >>> def f(a, data=None):
...
if data is None:
...
data = []
...
data.append(a)
...
return data
...
>>> print(f(1))
[1]
>>> print(f(2))
[2]

  3. 关键字参数

    >>> def func(a, b=5, c=10):
...
print('a is', a, 'and b is', b, 'and c is', c)
...
>>> func(12, 24)
a is 12 and b is 24 and c is 10
>>> func(12, c = 24)
a is 12 and b is 5 and c is 24
>>> func(b=12, c = 24, a = -1)
a is -1 and b is 12 and c is 24

    在上面的例子中你能看见调用函数时使用了变量名，比如 func(12,c = 24)，这样我们将 24 赋给 c 且 b 具有默认值。

  4. 文档字符串

    #!/usr/bin/env python3
import math
def longest_side(a, b):
"""
Function to find the length of the longest side of a right triangle.
:arg a: Side a of the triangle
:arg b: Side b of the triangle
:return: Length of the longest side c as float
"""
return math.sqrt(a*a + b*b)
if __name__ == '__main__':
print(longest_side.__doc__)
print(longest_side(4,5))

  5. 高阶函数：

    1. 使用一个或多个函数作为参数

    2. 返回另一个函数作为输出

    3. map()函数:它接受一个函数和一个序列（迭代器）作为输入，然后对序列（迭代器）的每一个值应用这个函数，返回一个序列（迭代器）

      >>> lst = [1, 2, 3, 4, 5]
>>> def square(num):
...
"返回所给数字的平方."
...
return num * num
...
>>> print(list(map(square, lst)))
[1, 4, 9, 16, 25]

异常

  1. 首先，执行
try
子句 （在
try
和
except
关键字之间的部分）。
如果没有异常发生，except
子句 在
try
语句执行完毕后就被忽略了。
如果在 try 子句执行过程中发生了异常，那么该子句其余的部分就会被忽略。
如果异常匹配于
except
关键字后面指定的异常类型，就执行对应的 except 子句。然后继续执行
try
语句之后的代码。
如果发生了一个异常，在
except
子句中没有与之匹配的分支，它就会传递到上一级
try
语句中。
如果最终仍找不到对应的处理语句，它就成为一个未处理异常，终止程序运行，显示提示信息。

  2. >>> def get_number():
...
"Returns a float number"
...
number = float(input("Enter a float number: "))
...
return number
...
>>>
>>> while True:
...
try:
...
print(get_number())
...
except ValueError:
...
print("You entered a wrong value.")
...
Enter a float number: 45.0
45.0
Enter a float number: 24,0
You entered a wrong value.
Enter a float number: Traceback (most recent call last):
File "<stdin>", line 3, in <module>
File "<stdin>", line 3, in get_number
KeyboardInterrupt

  3. 一个空的 except 语句能捕获任何异常

  4. 使用 raise 语句抛出一个异常

    >>> try:
...
raise ValueError("A value error happened.")
... except ValueError:
...
print("ValueError in our code.")
...
ValueError in our code.

  5. finally 子句，目的在于定义在任何情况下都一定要执行的功能

    finally 子句用于释放外部资源（文件或网络连接之类的），无论它们的使用过程中是否出错

    不管有没有发生异常，finally 子句 在程序离开 try 后都一定会被执行。当 try 语句中发生了未被 except 捕获的异常（或者它发生在 except 或 else 子句中），在 finally 子句执行完后它会被重新抛出。

    >>> try:
...
raise KeyboardInterrupt
... finally:
...
print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
File "<stdin>", line 2, in ?

  6. 使用 with 语句

    使用 with 语句处理文件对象，它会在文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写：

    >>> with open('sample.txt') as fobj:
...
for line in fobj:
...
print(line, end = '')
...
I love Python
I love shiyanlou

逻辑运算符

逻辑运算符 and 和 or 也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果 A 和 C 为真而 B 为假，A and B and C 不会解析 C 。作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数。

关系运算可以通过逻辑运算符 and 和 or 组合，比较的结果可以用 not 来取反意。逻辑运算符的优先级又低于关系运算符，在它们之中，not 具有最高的优先级，or 优先级最低，所以 A and not B or C 等于 (A and (notB)) or C。当然，括号也可以用于比较表达式。

>>> 5 and 4
# 首先判断5，肯定为true，那么最终的结果就取决于 and 后面那个的布尔值，4 的布尔值为 true，这样就可以确定整个表达式的值为 true 了，所以返回 4
4
>>> 0 and 4
# 首先判断0，因为 0 的布尔值为 false，那么不管 and 后面那个的布尔值是什么，整个表达式的布尔值都应该为 false 了，这个时候就不需要判断 4 了，直接返回最先确定结果的那个数也就是0
0
>>> False or 3 or 0
3
>>> 2 > 1 and not 3 > 5 or 4
True

虚拟环境

python虚拟环境搭建和包下载
python -m venv venv_name
1.
pip install -r requirements.txt
2.
cd /home/anwen/flask_venv/bin;
3.
source activate
4.
pip list
5.
deactivate
6.
cd ~

测试(waiting)

  1. pytest
  2. 各类 assert 语句

创建项目(waiting)

创建项目，编写 __init__ 文件
使用 setuptools 模块，编写 setup.py 和 MANIFEST.in 文件
创建源文件的发布版本
项目注册&上传到 PyPI

最后

以上就是娇气哈密瓜为你收集整理的大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)的全部内容，希望文章能够帮你解决大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(60)

相关文章

python parser解析_python 参数解析ArgumentParser
python parser解析_python 参数解析ArgumentParser
python之argparse参数解析模块使用1 默认参数default
python之argparse参数解析模块使用1 默认参数default
python中遇到的问题_Python中遇到的小问题及解决方法汇总
python中遇到的问题_Python中遇到的小问题及解决方法汇总
python 参数封装库 argparse 的使用
python 参数封装库 argparse 的使用
大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)
大二上 python 期末复习类(class)Collections 模块元组（tuple)集合（set）列表(list)字典(dict)字符串模块IO文件函数异常逻辑运算符虚拟环境测试(waiting)创建项目(waiting)
argparse模块的用法示例创建解析器添加参数解析参数ArgumentParser对象编程用法说明parentsformatter_class版本3.5中的新功能。
argparse模块的用法示例创建解析器添加参数解析参数ArgumentParser对象编程用法说明parentsformatter_class版本3.5中的新功能。
argparse模块（1）模块简介（2）Example（3）argparse三个主要函数：（4）ArgumentParser对象（5）add_argument()方法（6）parse_args()方法（7）The Namespace object
argparse模块（1）模块简介（2）Example（3）argparse三个主要函数：（4）ArgumentParser对象（5）add_argument()方法（6）parse_args()方法（7）The Namespace object
为什么网页中的java运行出错_已经开启parameter 参数，为何还是会报错？能够编译启动，但是网页运行错误...
为什么网页中的java运行出错_已经开启parameter 参数，为何还是会报错？能够编译启动，但是网页运行错误...

评论列表共有 0 条评论

立即
投稿
返回
顶部