DeepOps的Python小笔记-天池龙珠计划-Python训练营-Task 02:DAY4

进行到了训练营的第四天,进入了下一个环节Task2,Task2还是python的基础内容,主要包括:

  1. 列表
  2. 元组
  3. 字符串
  4. 字典
  5. 集合
  6. 序列
    DAY 4 的学习内容:列表、元组

1 列表

1.1 列表的定义

中括号包围,逗号分割

1.2 列表的创建

直接创建

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

利用range()创建

x = list(range(10))
x = list(range(1, 11, 2))
x = list(range(10, 1, -2))

利用推导式创建列表

x = [0] * 5
x = [0 for i in range(5)]
x = [i ** 2 for i in range(1, 10)]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]

创建一个混合列表

mix = [1, 'lsgo', 3.14, [1, 2, 3]]

创建一个空列表

empty = []

1.3 向列表中添加元素

list.append(obj) 在列表末尾添加新的对象,特别注意append和extend的区别

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']] 
print(len(x))  # 6

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

list.insert(index, obj) 在编号 index 位置插入 obj。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x))  # 6

1.4 删除列表中的元素

list.remove(obj) 移除列表中某个值的第一个匹配项

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x)  # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y)  # Friday

y = x.pop(0)
print(y)  # Monday

y = x.pop(-2)
print(y)  # Wednesday
print(x)  # ['Tuesday', 'Thursday']

直接使用序号去指定删除,del x[0:2],python的切片还是非常好用,想怎么切就怎么切。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

1.5 获取列表中的元素

切片的通用写法是 start : stop : step

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
# 情况 1 - "start :"
print(x[3:])  # ['Thursday', 'Friday']
print(x[-3:])  # ['Wednesday', 'Thursday', 'Friday']
# 情况 2 - ": stop"
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']
# 情况 3 - "start : stop"
print(week[1:3])  # ['Tuesday', 'Wednesday']
print(week[-3:-1])  # ['Wednesday', 'Thursday']
# 情况 4 - "start : stop : step"
print(week[1:4:2])  # ['Tuesday', 'Thursday']
print(week[:4:2])  # ['Monday', 'Wednesday']
print(week[1::2])  # ['Tuesday', 'Thursday']
print(week[::-1])  
# 情况 5 - " : "复制列表中的所有元素(浅拷贝)。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

浅拷贝与深拷贝 浅拷贝复制元素,不复制引用,深拷贝复制引用。

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

#list1 记录的是引用,深浅拷贝过去的都是引用,修改相同引用因此数据都发生变化
list1 = [[123, 456], [789, 213]] 
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

1.6 列表的常用操作符

等号操作符:==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
「等号 ==」,只有成员、成员位置都相同时才返回True。

列表拼接有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # 等同extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

1.7 列表的其他方法

list.count(obj) 统计某个元素在列表中出现的次数

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
list.reverse() 反向列表中元素
list.sort(key=None, reverse=False) 对原列表进行排序。

x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]


# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

2 元组

「元组」定义语法为:(元素1, 元素2, …, 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开

2.1 创建和访问一个元组

Python 的元组与列表类似,不同之处在于tuple(元组)被创建后就不能对其进行修改,类似字符串。
元组使用小括号,列表使用方括号。
元组与列表类似,也用整数来对它进行索引 (indexing) 和切片 (slicing)。
创建元组可以用小括号 (),也可以什么都不用,为了可读性,建议还是用 ()。
元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。
创建二维元组

x = (1, 10.31, 'python'), ('data', 11)
print(x)

2.2 更新和删除一个元组

t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
t1[1] = 9 #**会报错不可修改**
print(t1)  # (1, 2, 3, [9, 5, 6])

2.3 元组相关的操作符

等号操作符:==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
「等号 ==」,只有成员、成员位置都相同时才返回True。

元组拼接有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。

【例子】

2.4 内置方法

元组大小和内容都不可更改,因此只有 count 和 index 两种方法。

2.5 解压元组

解压(unpack)一维元组(有几个元素左边括号定义几个变量)

# 解压(unpack)一维元组
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

#例子】解压二维元组
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

DeepOps的Python小笔记-天池龙珠计划-Python训练营-Task 01:DAY3

今天的任务主要是异常处理,我目前写的python 还没用过异常处理。(换句话还没有正经写过)

异常处理

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 – except 语句:

try:
-     检测范围
- except Exception[as reason]:
-     出现异常后的处理代码

try – except – finally 语句:

def divide(x, y):
    try:
        result = x / y
        print("result is", result)     
    except ZeroDivisionError:
        print("division by zero!")
     finally:
        print("executing finally clause")

try – except – else 语句 :

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

raise语句

  • Python 使用raise语句抛出一个指定的异常。
try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    
# An exception flew by!

DeepOps的Python小笔记-天池龙珠计划-Python训练营-Task 01:DAY2

很快到了第二天 条件语句与循环语句

条件语句

if 语句

  • if – else 语句
  • if – elif – else 语句
  • assert 关键词
    • assert len(my_list) > 0

循环语句

while 循环

- while - else 循环
	- 这个我很少用过, 当while循环正常执行完的情况下,执行else输出,如果while循环中执行了跳出循环的语句,比如 break,将不执行else代码块的内容。
while 布尔表达式:
	代码块
else:
	代码块

for 循环

  • for – else 循环
  • 当for循环正常执行完的情况下,执行else输出,如果for循环中执行了跳出循环的语句,比如 break,将不执行else代码块的内容,与while – else语句一样。
for 迭代变量 in 可迭代对象:
     代码块
else:
     代码块

range() 函数

enumerate()函数

sequence:一个序列、迭代器或其他支持迭代对象。

  • 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')]

break 语句

  • 语句可以跳出当前所在层的循环。

continue 语句

pass 语句

- 要是我早知道有这么一个玩意儿,就不用在if语句里面写一个print()
- pass 语句的意思是“不做任何事”,如果你在需要有语句的地方不写任何语句,那么解释器会提示出错,而 pass 语句就是用来解决这些问题的。

推导式

这个一般教程少见,需要重点看一下

列表推导式

  • [ expr for value in collection [if condition] ]
x = [-4, -2, 0, 2, 4]
y = [a - 2 for a in x]
print(y)
# [-8, -4, 0, 4, 8]

元组推导式

  • ( 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, 2, 4, 6, 8, 10, 12, 14, 16, 18)

字典推导式

  • { key_expr: value_expr for value in collection [if condition] }
b = {i: i % 2 == 0 for i in range(20) if i % 3 == 0}
print(b)
{0: True, 3: False, 6: True, 9: False, 12: True, 15: False, 18: True}

集合推导式

  • { 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}

其它

  • next(iterator[, default])
  • Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.
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`

DeepOps的Python小笔记-天池龙珠计划-Python训练营-Task 01:DAY1

**龙珠计划python训练营地址:https://tianchi.aliyun.com/specials/promotion/aicamppython
龙珠计划还包括SQL、数学、机器学习、深度学习、强化学习等,图标做的非常有意思,很容易激发收集控的一面。作为一个python跟着不同的学习小组,学过好几遍的人,为了凑齐龙珠,也要再刷一遍,才能达到内心的平静。

除了这个龙珠计划,天池学习还构建了一颗知识树,详情请见如下链接:https://tianchi.aliyun.com/course/index 看上去感觉不错,但是也要先完成龙珠计划。

整个python训练营分成了5个任务分别是:
Task1:python基础入门:从变量到异常处理(3天)
Task2:python基础练习:数据结构大汇总(3天)
Task3:python基础进阶:从函数到高级魔法方法(3天)
Task4:python数据分析:从0完成一个数据分析实战(1天)
Task5:python训练营测试(1天)
总共算下来11天就能搞定。


变量、运算符与数据类型

注释

#账号注释,单个单引号或者双引号 多行注释

运算符

  • 算术运算符
    • 加减乘除
    • 整除 3//4
    • 取余3%4 幂 2**3
  • 逻辑运算符
    • and 与
    • or 或
    • not 非
  • 位运算符
    • ~ 按位取反 ~4
    • & 按位与 4 & 5
    • | 按位或
    • ^ 按位异或 4 ^ 5
    • << 左移 4 << 2
    • >> 右移 4 >> 2
  • 三元运算符
    small = x if x < y else y 这个看起来比较厉害,记录一下
  • 其他运算符
    • in 、not in
    • ==, != 对比的是两个变量的值
    • is 、not is : is, is not 对比的是两个变量的内存地址
  • 运算符的优先级

变量和赋值

  • 变量名可以包括字母、数字、下划线、但变量名不能以数字开头。

数据类型与转换

  • 可以通过type(x)来查看,类的类型
  • bin(整型) 转换为二进制字符串,整型.bit_lenght()二进制长度
  • from decimal import Decimal 用来处理浮点数
  • bool 作用在基本类型变量:X 只要不是整型 0、浮点型 0.0,bool(X) 就是 True,其余就是 False。
  • 类型判断
    • type() 不会认为子类是一种父类类型,不考虑继承关系。
    • isinstance() 会认为子类是一种父类类型,考虑继承关系

print() 函数

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

位运算

原码、反码和补码 我的老大难

  • 二进制有三种不同的表示形式:原码、反码和补码,计算机内部使用补码来表示。
  • 原码:就是其二进制表示(注意,有一位符号位)。
    • 00 00 00 11 -> 3
    • 10 00 00 11 -> -3
  • 反码:正数的反码就是原码,负数的反码是符号位不变,其余位取反(对应正数按位取反)。
    • 00 00 00 11 -> 3
    • 11 11 11 00 -> -3
  • 补码:正数的补码就是原码,负数的补码是反码+1。
    • 00 00 00 11 -> 3
    • 11 11 11 01 -> -3
  • 符号位:最高位为符号位,0表示正数,1表示负数。在位运算中符号位也参与运算。

按位运算

  • 按位非操作 ~
  • 按位与操作 &
  • 按位或操作 |
  • 按位异或操作 ^
  • 按位左移操作 <<
  • 按位右移操作 >>

利用位运算实现快速计算

  • 通过 <<,>> 快速计算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

利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合(0 表示不在集合中,1 表示在集合中)。
比如集合 {1, 3, 4, 8},可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

  • 元素与集合的操作:
    • a | (1<<i) -> 把 i 插入到集合中
    • a & ~(1<<i) -> 把 i 从集合中删除
    • a & (1<<i) -> 判断 i 是否属于该集合(零不属于,非零属于)
  • 集合之间的操作:
    • a 补 -> ~a
    • a 交 b -> a & b
    • a 并 b -> a | b
    • a 差 b -> a & (~b)
      注意:整数在内存中是以补码的形式存在的,输出自然也是按照补码输出。

15 个提高效率的 Python 编程技巧 (转)

转自:https://www.infoq.cn/article/gGWTBjWt3xHiEQQQMgJa

英文原文: 15 Python tips and tricks, so you don’t have to look them up on Stack Overflow

做个笔记,留文存档。

1. 交换值

x, y = 1, 2
print(x, y)
x, y = y, x
print(x, y)

2. 字符串列表合并为一个字符串

sentence_list = ["my", "name", "is", "George"]
sentence_string = " ".join(sentence_list)
print(sentence_string)

3. 将字符串拆分为子字符串列表

sentence_string = "my name is George"
sentence_string.split()
print(sentence_string)

4. 通过数字填充初始化列表

[0]*1000 # List of 1000 zeros 
[8.2]*1000 # List of 1000 8.2's

5. 字典合并

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
z = {**x, **y}

6. 反转字符串

name = "George"
name[::-1]

7. 从函数返回多个值

def get_a_string():
  a = "George"
  b = "is"
  c = "cool"
  return a, b, c
sentence = get_a_string()
(a, b, c) = sentence

8. 列表解析式

a = [1, 2, 3]
b = [num*2 for num in a] # Create a new list by multiplying each element in a by 2

9. 遍历字典

m = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 
for key, value in m.items():
  print('{0}: {1}'.format(key, value))

10. 同时遍历列表的索引和值

m = ['a', 'b', 'c', 'd']
for index, value in enumerate(m):
  print('{0}: {1}'.format(index, value))

11. 初始化空容器

a_list = list()
a_dict = dict()
a_map = map()
a_set = set()

12. 删除字符串两端的无用字符

name = "  George "
name_2 = "George///"
name.strip() # prints "George"
name_2.strip("/") # prints "George"

13. 列表中出现最多的元素

test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4]
print(max(set(test), key = test.count))

14. 检查对象的内存使用情况

import sys
x = 1
print(sys.getsizeof(x))

15. 将 dict 转换为 XML

from xml.etree.ElementTree import Element
def dict_to_xml(tag, d):
    '''
    Turn a simple dict of key/value pairs into XML
    '''
    elem = Element(tag)
    for key, val in d.items():
        child = Element(key)
        child.text = str(val)
        elem.append(child)
    return elem