零基础5天入门Python数据分析：第四课

data = [1, 2, 3]

# 使用循环的写法
new_data = []
for val in data:
    new_data.append(val**2)

print(new_data)

data = [1, 2, 3]

# 使用推导式的写法
# 如果是元组，则将下面语句的中括号改为小括号
new_data = [val**2 for val in data]
print(new_data)

[func(item) for item in data]

a = [1, 3, 6]
b = [2, 1, 3]

# 如果我们需要计算：
# a的每个元素和b的每个元素的乘积
c = [ia*ib for ia, ib in zip(a, b)]
print(c)

data = [4, 1, 2, 3, 5, 7, 8]

# 如果我们需要计算：
# data的偶数位上的数的平方
new_data = [val**2 for key, val in enumerate(data) if key % 2 == 1]
print(new_data)

# 只需要把中括号改成大括号即可
new_data = {val**2 for key, val in enumerate(data) if key % 2 == 1}
print(new_data)

{key: val for key, val in zip(keys, values)}

# 姓名和成绩
names = ['张三', '李四', '王五']
scores = [66, 89, 59]

# 使用字典推导式定义一个字典
# 将姓名和成绩关联起来
data = {name: score for name, score in zip(names, scores)}
print(data)

# 将一个字典复制到另一个字典也可以这样写：
data1 = {'张三': 66, '李四': 89, '王五': 59}
data2 = {k: v for k, v in data1.items()}
print(data2)

# 函数名的后面，加一个问号，然后运行单元格
# 以range函数为例：
range?

Init signature: range(self, /, *args, **kwargs)
Docstring:
range(stop) -> range object
range(start, stop[, step]) -> range object

Return an object that produces a sequence of integers from start (inclusive)
to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
These are exactly the valid indices for a list of 4 elements.
When step is given, it specifies the increment (or decrement).
Type:           type
Subclasses:

range(stop) -> range object
range(start, stop[, step]) -> range object

data1 = range(10)
data2 = range(5, 10)
data3 = range(5, 10, 2)

# 我们将这3个结果转成列表来观察结果
print(list(data1))
print(list(data2))
print(list(data3))

Signature: str.replace(self, old, new, count=-1, /)
Docstring:
Return a copy with all occurrences of substring old replaced by new.

  count
    Maximum number of occurrences to replace.
    -1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are
replaced.
Type:      method_descriptor

s = 'This is a string string.'
# 调用的方式跟上面说到的内置函数有点点不同
new_s = s.replace('string', '字符串')
print(new_s)

# 这种方式也是完全一样的
s = 'This is a string.'
s.replace?

s = 'This is a string'

# 按空格分拆字符串
ls = s.split(' ')
print(ls)

# 使用一个等号将列表拼接起来，组成一个新的字符串
'='.join(ls)

# 定义一个函数：nine_nine_multi
def nine_nine_multi():
    for i in range(1, 10):           # 注意缩进
        for j in range(1, i+1):
            print("%d * %d = %d" % (i, j, i*j))
    # return None

# 函数调用
nine_nine_multi()

# 定义列表的求和函数
# list_sum是函数名
# ls是函数的参数
# 注意：理解缩进的层级
def list_sum(ls):
    ls_sum = 0
    for val in ls:
        ls_sum += val

    # 返回语句
    return ls_sum      # 返回计算结果

a = [1,2,3,4,5]
a_sum = list_sum(a)
print(a_sum)

# a是必选参数
# b就是带默认值的参数
def test(a, b=2):
    print(a, b)

# 不传b参数，则b参数使用默认值
test(1)
# 给b参数参数，通常这样：b=4
test(1, b=4)

range?

def test(a):
    local_a = 20    # 定义一个函数内部的变量
    print(a)
    print(global_a)       # 这里会打印10

# 定义一个全局变量
global_a = 10
param = 15
test(param)

# 在函数外部使用函数内部的变量会报错
print(local_a)

def test(a):
    # 在函数内部改变重新定义之后，global_a这个变量已经变成了该函数的内部变量
    # 在这里改变重新赋值并不会影响全局的global_a
    global_a = 5    
    print('In test: ', global_a)    # output: 5


# 定义一个全局变量
global_a = 10
print('Global: ', global_a)    # output: 10
test(20)

# 外部的变量并不会改变
print('Global: ', global_a)    # output: 10

def test(a):
    global global_a      # 声明该变量是全局变量
    global_a += 5
    print('In test: ', global_a)


# 定义一个全局变量
global_a = 10
print('Global: ', global_a)
test(20)
print('Global: ', global_a)

Global:  10
In test:  15
Global:  15

Signature: sorted(iterable, /, *, key=None, reverse=False)
Docstring:
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
Type:      builtin_function_or_method

a = [1, 3, 2]
print(sorted(a))    # output: 1,2,3
print(sorted(a, reverse=False))    # output: 1,2,3

# 逆序排序
print(sorted(a, reverse=True))    # output: 3,2,1

[1, 2, 3]
[1, 2, 3]
[3, 2, 1]

# 定义一个列表: 一个班级学生的考试成绩如下
scores = [
    ['张三', 80],
    ['李四', 70],
    ['王五', 90]
]

# 定义一个key参数的值
def score_sort(x):
    return x[1]     # 指定按照下标1的值，即成绩进行排序

# 如果我们按成绩进行排名
# 这告诉我们，函数也是一个对象，可以作为其他函数的参数，也可以赋值给一个变量
res = sorted(scores, key=score_sort, reverse=True)
print(res)

[['王五', 90], ['张三', 80], ['李四', 70]]

res = sorted(scores, key=lambda x: x[1], reverse=True)
print(res)

# 定义一个字符串变量
# s就是一个字符串对象
s = 'string!'
# 调用s对象的replace方法
s.replace('!', '.')

# 在使用包的函数，需要先引入该包
import math       # 这时包引用的语句

# PI的值
# 包的变量：pi是在math这个包中定义好的常量
print(math.pi)

# 求平方根
# sqrt是math包中定义的函数
print(math.sqrt(2))

# 查看包函数的帮助文档
# 如果帮助信息不清晰，则可以使用搜索引擎进行搜索
math.sqrt?

# 将numpy引入进来，并命名为np，这时在代码中就可以使用np进行调用
# numpy是一个数据分析常用的第三方包
import numpy as np

# 从math包中单独引入sqrt这个函数
from math import sqrt

from copy import deepcopy

a = [1, 2, ["a", "b", "c"]]
# deep copy a to b
b = deepcopy(a)

# change 
a[2][1] = 'abc'
print(b)

[1, 2, ['a', 'b', 'c']]