Python基础组队学习

Python基础组队学习

Task1变量、运算符与数据类型及位运算

is, is not 对比的是两个变量的内存地址
==, != 对比的是两个变量的值
比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

运算符的优先级
一元运算符优于二元运算符。例如3 ** -2等价于3 ** (-2)。
先算术运算，后移位运算，最后位运算。例如 1 << 3 + 2 & 7等价于 (1 << (3 + 2)) & 7。
逻辑运算最后结合。例如3 < 4 and 4 < 5等价于(3 < 4) and (4 < 5)。

查看有什么属性

print(dir(list))

保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。

import decimal
from decimal import Decimal
a = decimal.getcontext() # 默认28位

decimal.getcontext().prec = 4  # 调整精度值
c = Decimal(1) / Decimal(3)
print(c)

当把布尔型变量用在数字运算中，用 1 和 0 代表 True 和 False。
bool 作用在基本类型变量：X 只要不是整型 0、浮点型 0.0，bool(X) 就是 True，其余就是 False。
bool 作用在容器类型变量：X 只要不是空的变量，bool(X) 就是 True，其余就是 False。

获取类型信息

• isinstance(object, classinfo) 判断一个对象是否是一个已知的类型。
• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。
  如果要判断两个类型是否相同推荐使用 isinstance()。

类型转换

• 转换为整型 int(x, base=10)
• 转换为字符串 str(object=’’)
• 转换为浮点型 float(x)

print函数
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

• 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出；
• 关键字参数sep是实现分隔符，比如多个参数输出时想要输出中间的分隔字符；
• 关键字参数end是输出结束时的字符，默认是换行符\n；
• 关键字参数file是定义流输出的文件，可以是标准的系统输出sys.stdout，也可以重定义为别的文件；
• 关键字参数flush是立即把内容输出到流文件，不作缓存。

位运算
利用位运算实现快速计算
通过 <<，>> 快速计算2的倍数问题。

n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n

通过 ^ 快速交换两个整数。

a ^= b
b ^= a
a ^= b

通过 a & (-a) 快速获取a的最后为 1 位置的整数。

00 00 01 01 -> 5
&
11 11 10 11 -> -5
---
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
---
00 00 00 10 -> 2

位操作交换两数可以不需要第三个临时变量，虽然普通操作也可以做到，但是没有其效率高//普通操作

void swap(int &a, int &b) {
  a = a + b;
  b = a - b;
  a = a - b;
}

//位与操作
void swap(int &a, int &b) {
  a ^= b;
  b ^= a;
  a ^= b;
}

位与操作解释：第一步：a ^ = b —> a = (a^b);

第二步：b = b^a = b ^ (a ^ b) = a

第三步：a ^= b —> a = (a ^b) ^ a = (a ^ a) ^ b = b

练习题

1. 怎样对python中的代码进行注释？
   使用 " ```" 或者 “ # ”
2. python有哪些运算符，这些运算符的优先级是怎样的？
   一元运算符优于二元运算符。先算术运算，后移位运算，最后位运算。逻辑运算最后结合。
3. python 中 is, is not 与 ==, != 的区别是什么？
   is, is not 对比的是两个变量的内存地址
   ==, != 对比的是两个变量的值
4. python 中包含哪些数据类型？这些数据类型之间如何转换？
   有整型、浮点型、布尔型。通过三个函数int 、str、float转换。
5. 只出现一次的数字。给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。尝试使用位运算解决此题。

#Input file
#example1: [2,2,1]
#example2: [4,1,2,1,2]

#Output file
#result1: 1
#result2: 4

class Solution:
    def singleNumber(self, nums: List[int]) -> int:        
     # your code here

不懂class和def那一句什么意思，只能这样表达一下意思了。
list1 = [1, 1, 2, 2, 3]
result = list1[0]
for i in range(1, len(list1)):
    result = result ^ list1[i]
print(result)

Task2 条件语句，循环语句

temp = input(“猜一猜小姐姐想的是哪个数字？”)
guess = int(temp) # input 函数将接收的任何数据类型都默认为 str。

assert这个关键词我们称之为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出AssertionError的异常。

如果布尔表达式不带有<、>、==、！=、in、not in等运算符，仅仅给出数值之类的条件，也是可以的。当while后写入一个非零整数时，视为真值，执行循环体；写入0时，视为假值，不执行循环体。也可以写入str、list或任何序列，长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。

string = 'abcd'
while string:
    print(string)
    string = string[1:]

当while循环正常执行完的情况下，执行else输出，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容。
for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，也可以遍历任何可迭代对象，如dict。

dic = {
   'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep=':', end=' ')  
# a:1 b:2 c:3 d:4 

for key in dic.keys():
    print(key, end=' ')
    
# a b c d 

for value in dic.values():
    print(value, end=' ')
    
# 1 2 3 4

if中的break跳出哪一个循环？哪儿有else跳到哪儿？？？

for num in range(10, 20):  # 迭代 10 到 20 之间的数字
    for i in range(2, num):  # 根据因子迭代
        if num % i == 0:  # 确定第一个因子
            j = num / i  # 计算第二个因子
            print('%d 等于 %d * %d' % (num, i, j))
            break  # 跳出当前循环
    else:  # 循环的 else 部分
        print(num, '是一个质数')

# 10 等于 2 * 5
# 11 是一个质数
# 12 等于 2 * 6
# 13 是一个质数
# 14 等于 2 * 7
# 15 等于 3 * 5
# 16 等于 2 * 8
# 17 是一个质数
# 18 等于 2 * 9
# 19 是一个质数

enumerate()函数

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
lst = list(enumerate(seasons))
print(lst)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
lst = list(enumerate(seasons, start=1))  # 下标从 1 开始
print(lst)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

enumerate()与 for 循环的结合使用

for i, a in enumerate(A)
    do something with a  

continue 语句

for i in range(10):  # 对了，continue、break终止的是循环，if不算
    if i % 2 != 0:
        print(i)
        continue
    i += 2
    print(i)

pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行。

列表推导式

[ expr for value in collection [if condition] ]

x = [-4, -2, 0, 2, 4]
y = [a * 2 for a in x]
print(y)

x = [i ** 2 for i in range(1, 10)]

x = [(i, i ** 2) for i in range(6)]

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]

a = [(i, j) for i in range(0, 3) for j in range(0, 3)]

x = [[i, j] for i in range(0, 3) for j in range(0, 3)]

a = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]

元组推导式

( expr for value in collection [if condition] )

a = (x for x in range(10))
print(a)
# <generator object <genexpr> at 0x0000025BE511CC48>
print(tuple(a))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

字典推导式

{
    key_expr: value_expr for value in collection [if condition] }

b = {
   i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

集合推导式

{
    expr for value in collection [if condition] }

c = {
   i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

其它

d = 'i for i in "I Love Lsgogroup"'
print(d)
# i for i in "I Love Lsgogroup"

e = (i for i in range(10))
print(e)
# <generator object <genexpr> at 0x0000007A0B8D01B0>

print(next(e))  # 0
print(next(e))  # 1

for each in e:
    print(each, end=' ')

# 2 3 4 5 6 7 8 9

s = sum([i for i in range(101)])
print(s)  # 5050
s = sum((i for i in range(101)))
print(s)  # 5050

练习题

1. 编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字，介于1500和2700之间。

num = [i for i in range(1500, 2700) if i%7==0 and i%5==0]

2. 龟兔赛跑游戏
   题目描述：
   话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔 子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以 上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。
   然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1 米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找 到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。
   输入:
   输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2< =100;t< =300;s< =10;l< =10000且为v1,v2的公倍数)
   输出:
   输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
   第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。
   样例输入：
   10 5 5 2 20
   样例输出
   D
   4

v1, v2, t, s, l = map(int, input().split())
time = 0
while time < l/v2+1:
    s1 , s2 = 0, 0
    s1 = v1 + s1
    s2 = v2 + s2
    time += 1
    if s1 >= s2 + t:
        s2 = s2 + v2 * s
        time = time + s
print(s1, s2)
if s1 == s2:
    print("d")
elif s1 > s2:
    print("R")
else:
    print("T")

#10 5 5 2 20
#10 15
#T   结果不对，但又不知道哪儿有问题，先打卡了。。。去看看别人怎么写

# 琢磨了一下，这样强行把结果改对了
v1, v2, t, s, l = map(int, input().split())
time = 1
s1 = v1
s2 = v2
while time < l/v2:
    if s1 >= s2 + t:
        s2 = s2 + v2 * s
        time = time + s
    else:
        s1 = v1 + s1
        s2 = v2 + s2
        time += 1

print(s1, s2)
if s1 == s2:
    print("d")
elif s1 > s2:
    print("R")
else:
    print("T")

task3异常处理

Python 标准异常总结

• BaseException：所有异常的 基类
• Exception：常规异常的 基类
• StandardError：所有的内建标准异常的基类
• ArithmeticError：所有数值计算异常的基类
• FloatingPointError：浮点计算异常
• OverflowError：数值运算超出最大限制
• ZeroDivisionError：除数为零
• AssertionError：断言语句（assert）失败
• AttributeError：尝试访问未知的对象属性
• EOFError：没有内建输入，到达EOF标记
• EnvironmentError：操作系统异常的基类
• IOError：输入/输出操作失败
• OSError：操作系统产生的异常（例如打开一个不存在的文件）
• WindowsError：系统调用失败
• ImportError：导入模块失败的时候
• KeyboardInterrupt：用户中断执行
• LookupError：无效数据查询的基类
• IndexError：索引超出序列的范围
• KeyError：字典中查找一个不存在的关键字
• MemoryError：内存溢出（可通过删除对象释放内存）
• NameError：尝试访问一个不存在的变量
• UnboundLocalError：访问未初始化的本地变量
• ReferenceError：弱引用试图访问已经垃圾回收了的对象
• RuntimeError：一般的运行时异常
• NotImplementedError：尚未实现的方法
• SyntaxError：语法错误导致的异常
• IndentationError：缩进错误导致的异常
• TabError：Tab和空格混用
• SystemError：一般的解释器系统异常
• TypeError：不同类型间的无效操作
• ValueError：传入无效的参数
• UnicodeError：Unicode相关的异常
• UnicodeDecodeError：Unicode解码时的异常
• UnicodeEncodeError：Unicode编码错误导致的异常
• UnicodeTranslateError：Unicode转换错误导致的异常
  
  Python标准警告总结
• Warning：警告的基类
• DeprecationWarning：关于被弃用的特征的警告
• FutureWarning：关于构造将来语义会有改变的警告
• UserWarning：用户代码生成的警告
• PendingDeprecationWarning：关于特性将会被废弃的警告
• RuntimeWarning：可疑的运行时行为(runtime behavior)的警告
• SyntaxWarning：可疑语法的警告
• ImportWarning：用于在导入模块过程中触发的警告
• UnicodeWarning：与Unicode相关的警告
• BytesWarning：与字节或字节码相关的警告
• ResourceWarning：与资源使用相关的警告

try:  # 例子1
    int("abc")
    s = 1 + '1'
    f = open('test.txt')
    print(f.read())
    f.close()
except OSError as error:
    print('打开文件出错\n原因是：' + str(error))
except TypeError as error:
    print('类型出错\n原因是：' + str(error))
except ValueError as error:
    print('数值出错\n原因是：' + str(error))

dict1 = {
   'a': 1, 'b': 2, 'v': 22}  # 例子2
try:
    x = dict1['y']
except LookupError:
    print('查询错误')
except KeyError:
    print('键错误')
else:
    print(x)
# 查询错误

try-except-else语句尝试查询不在dict中的键值对，从而引发了异常。这一异常准确地说应属于KeyError，但由于KeyError是LookupError的子类，且将LookupError置于KeyError之前，因此程序优先执行该except代码块。所以，使用多个except代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。

try:  # 一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。
    s = 1 + '1'
    int("abc")
    f = open('test.txt')
    print(f.read())
    f.close()
except (OSError, TypeError, ValueError) as error:
    print('出错了！\n原因是：' + str(error))
# 出错了！
# 原因是：unsupported operand type(s) for +: 'int' and 'str'

try - except - finally 语句

try:
    检测范围
except Exception[as reason]:
    出现异常后的处理代码
finally:
    无论如何都会被执行的代码

def divide(x, y):  # 例子
    try:
        result = x / y
        print("result is", result)
    except ZeroDivisionError:
        print("division by zero!")
    finally:
        print("executing finally clause")
divide(2, 1)
# result is 2.0
# executing finally clause
divide(2, 0)
# division by zero!
# executing finally clause
divide("2", "1")
# executing finally clause
# TypeError: unsupported operand type(s) for /: 'str' and 'str'

try - except - else 语句

try:
    检测范围
except:
    出现异常后的处理代码
else:
    如果没有异常执行这块代码

try:
    检测范围
except(Exception1[, Exception2[,...ExceptionN]]]):
   发生以上多个异常中的一个，执行这块代码
else:
    如果没有异常执行这块代码

raise语句,Python 使用raise语句抛出一个指定的异常。

try: 
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')   
# An exception flew by!

练习题

1、猜数字游戏
题目描述:
电脑产生一个零到100之间的随机数字，然后让用户来猜，如果用户猜的数字比这个数字大，提示太大，否则提示太小，当用户正好猜中电脑会提示，“恭喜你猜到了这个数是…”。在用户每次猜测之前程序会输出用户是第几次猜测，如果用户输入的根本不是一个数字，程序会告诉用户"输入无效"。
(尝试使用try catch异常处理结构对输入情况进行处理)
获取随机数采用random模块。

import random
def game_guess_num(a, b):
    Num = random.randint(a, b)
    n = 1
    while True:
        select = input("第 %d 次，请输入一个整型数字:" %n)
        try:
            if