Python数据分析训练营——Python基础语法

1.Python数据分析之前奏

1.1 Python基本语法

Python使用Python使用<变量名>=<表达式>的方式对变量进行赋值

a=1
a

1

s = 'hello world'
s

'hello world'

(1)数据类型

字符串

字符串的定义是使用引号来定义，单引号与双引号是等价的

s='hello world'
s

'hello world'

三引号用来输入包含多行文字的字符串（可以是单引号也可以是双引号）

s='''hello
my
world'''
print(s)

hello
my
world

字符串的加法

s="hello"+"worrld"
s

'helloworrld'

字符串索引(索引号从0开始)

s[1]

'e'

字符串的分割（spilt方法，可以按照自己指定的方法分割，默认是空格）

s="helloworld"
s.split('o')

['hell', 'w', 'rld']

s="hello,world"
s.split(",")

['hello', 'world']

查看字符串的长度

len(s)

11

整数

b=100
b

100

浮点数

c=3.8
c

3.8

布尔值

a=True
a

True

a=1>2
a

False

空值

a=''
a

''

len(a)

0

a = None
print(a)

None

运算符

运算符：http://www.runoob.com/python/python-operators.html#ysf4

基本运算

2**3 #幂运算

8

9%2 #取余运算

1

9//2 #取整除-返回商的整数部分

4

比较运算

1 != 2
#2 <> 2 #都是不等于的写法，貌似后面这个在3以后的版本里就不支持了

True

1>2

False

3==3 #等式两边比较

True

赋值运算

a=2
a*=3 #a=a*3
a

6

逻辑运算

&-and，a&b只有当ab都是True的时候，结果才是True，否则都是False

a=True
b=False
a&b

False

a=3>2
b=4>3
a&b

True

|-or，a|b，当ab有一个为True的时候，结果就是True，两个都是False的时候结果才是False
(注意或运算有短路的现象，左边表达式成立的话右边将不会执行）

a=1>2
b=4>3
a|b

True

not 取反

not a

True

(2)数据结构

列表List

Python用[]来生成列表，也可以用list关键字

a=[1,2,3,4,5]
a

[1, 2, 3, 4, 5]

actors=['周迅','章子怡','赵薇']
actors

['周迅', '章子怡', '赵薇']

b=[1,2.3,'a','b']
b #列表中的元素允许各个元素不一样

[1, 2.3, 'a', 'b']

list('abcde') #利用list生成列表

['a', 'b', 'c', 'd', 'e']

列表操作

a+b #将两个链表链接在一起

[1, 2, 3, 4, 5, 1, 2.3, 'a', 'b']

a[0] #索引号，从0开始

1

a.append(6) #append方法，在末尾增加一个数
a

[1, 2, 3, 4, 5, 6]

a.insert(1,10) #insert方法，索引号，值
a

[1, 10, 2, 3, 4, 5]

a.pop() #pop方法，默认是删除最后一个元素，在里面写数字的话是写索引号
a

[10, 10]

a.pop(1)
a

[10]

a[0:3] #数据切片，左闭右开区间
a[-1] #-1表示倒数第一个数
a[-3:-1] #负索引切片
a[:3]
a[-3:] #不写的话默认从左边第一个开始或者取到右边最后一个

[3, 4, 5]

b=[1,2,3,4,5,6,7,8,9]
#b=[a:b:i] #间隔取值，前面区间仍然是左闭右开，后面为步长，同样也适用于负数的情况
b[2:9:3]

[3, 6, 9]

元组tuple

另一种有序列表叫元组：tuple，用（）来表示。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出演员的名字：

a = (1,2,3,4,5)
#a.pop() #报错，'tuple' object has no attribute 'pop'
a #用途：作为一个常量防止数据被篡改

(1, 2, 3, 4, 5)

字典 dict

Python用{key:value}来生成Dictionary

字典里面的数据可以是任何数据类型，也可以是字典

mv = {"name":"肖申克的救赎","actor":"罗宾斯","score":9.6,"country":"USA"}
mv

{'name': '肖申克的救赎', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}

mv["actor"]

'罗宾斯'

mv.keys()

dict_keys(['name', 'actor', 'score', 'country'])

mv.values()

dict_values(['肖申克的救赎', '罗宾斯', 9.6, 'USA'])

mv.items()

dict_items([('name', '肖申克的救赎'), ('actor', '罗宾斯'), ('score', 9.6), ('country', 'USA')])

mv["name"] = "泰坦尼克号"
mv

{'name': '泰坦尼克号', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}

mv["director"] = "德拉邦特"
mv

{'name': '泰坦尼克号',
 'actor': '罗宾斯',
 'score': 9.6,
 'country': 'USA',
 'director': '德拉邦特'}

mv.pop("director")
mv

{'name': '泰坦尼克号', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}

集合set

Python用{}来生成集合，集合不含有相同元素

s = {2,3,4,2}#自动删除重复数据
s

{2, 3, 4}

len(s)

3

s.add(1) #如果加入集合中已有元素没有任何影响
s

{1, 2, 3, 4}

s1 = {2,3,5,6}
s1

{2, 3, 5, 6}

s & s1 #取交集

{2, 3}

s | s1 #取并集

{2, 3, 4, 5, 6}

s - s1 #差集

{1, 4}

# s.remove(2) #删除集合s中一个元素，注意只能删除一次
s.pop() #[往前删]
# s.clear() #一键清空
s

{3, 4}

平时列表和字典用的是最多的

可变对象和不可变对象

可变对象可以对其进行插入，删除等操作，不可变对象不可以对其进行有改变的操作。Python中列表，字典，集合等都是可变的，元组，字符串，整型等都是不可变的。

类型转换

int(3.14)

3

float(3)

3.0

s = "abcd"
type(s) #str

str

list(s)

['a', 'b', 'c', 'd']

(3)判断和循环

2 == 2

True

97 == 'a'

False

'a' == 'A'

False

if 2>1:
    print('hello')

hello

a = 1
b = 2
if a>b:
    print("a大于b")
else:
    print("a小于等于b")

a小于等于b

x = 0
if x>0:
    print("x为正")
elif x==0:
    print("x为0")
else:
    print("x为负")

x为0

for i in range(5):#(1,2,3,4,5):#[1,2,3,4,5]:#[1,2,3,3,4]#列表元组集合字典字符串都行
    print(i)

0
1
2
3
4

i=1
while i<10:
    print(i)
    i=i+1

1
2
3
4
5
6
7
8
9

#判断，循环一起连用
for i in [1,2,3,4,5,6,7,8,9]:
    if(i%2)==1:
        print(i)

1
3
5
7
9

注意语句块一定要缩进，缩进要一致，最好是一个tab，美观整洁方便

{3,4,5,6,3,1,2,3}

{1, 2, 3, 4, 5, 6}

(4)列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式

list(range(1,11)) #range(1,11)迭代器,左闭右开，只有一个参数从0开始，两个参数是区间，三个参数最后一个数是跨度，不写的时候默认跨度为1

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[x**2 for x in range(1,10)] #列表生成平方

[1, 4, 9, 16, 25, 36, 49, 64, 81]

[i for i in range(1,100) if i%10 == 0]

[10, 20, 30, 40, 50, 60, 70, 80, 90]

[str(x) for x in range(1,10)]

['1', '2', '3', '4', '5', '6', '7', '8', '9']

[int(x) for x in list("123456789")]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.2 Python函数

(1)内置函数（可以在Python网站上查的到）

abs(-1)

1

a =[2,3,1,-4,12,6]
max(a)

12

min(a)

-4

sum(a)#求和

20

(2)自定义函数

函数function，通常接受输入参数，并有返回值

它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

函数通常有以下几个特征

1、使用def关键词来定义一个函数。

2、def后面是函数的名称，括号中是函数的参数，不同的参数用,隔开，def func():的形式是必须要有的，参数可以为空。

3、使用缩进来划分函数的内容。

4、return返回特定的值，如果省略，返回None。

def add(x,y):
    a = x+y
    return a

print(add(2,3))

5

使用函数时，只需要讲参数换成特定的值传给参数。

Python并没有限定参数的类型，因此可以使用不同的参数类型：

print(add(1,2.3))

3.3

在这个例子中，如果传入的两个参数不可以相加，那么Python将会报错

#print(add(2,'a')) #报错
print(add('2','a'))

2a

如果传入的参数与实际不符合，也会报错

#add(1) #报错

可以在函数定义的时候给参数设定默认值，例如

def func(x,a=1,b=0,c=0):
    return a*x**2+b**x+c

func(10)
func(10,1,1,1)

102

一个函数也可以返回多个返回值

def f(x):
    return x**2,x**3

f(2) #返回元组

(4, 8)

2.第一次课作业

（1）python基础语法。

（1）下面两段代码输出的结果相同么？请解释原因。
① x=4，y=5，print（x+y）
② x=‘4’,y=‘5’, print(x+y)

x1=4
y1=5
print(x1+y1)
x='4'
y='5'
print(x+y)

9
45

（2）‘10/3’，‘10//3’和’10%3’结果相同么？请说明原因。

print(10/3,' ',10//3,' ',10%3)

3.3333333333333335   3   1

（3）string1=‘I’m a student.’ 。print(string1)结果会报错么？如何修改string1使其得到正确的输出？

string1="I m a student."
print(string1)

I m a student.

（4） a = 3，str(a*3) + str(a)*3的输出是什么?

a=3
str(a*3)+str(a)*30

'9333333333333333333333333333333'

（5）my_string = ‘this is my string’, 如何查看这个字符串长度？

my_string = 'this is my string'
len(my_string)

17

（6）a,b = 4,5,a大于b 或 b大于等于5。请写出这里逻辑运算的代码，并查看输出会是什么。

a,b=4,5
print((a>b)|(b>=5))

True

（7）'=‘和’=='分别表示什么含义？print(2==5)输出什么结果？属于什么类型数据？

print(2==5)

False

（8）计算：100%(2+2)**3//5

print(100%(2+2)**3//5)
print(100%64//5)#先乘方，再取模，再整除

7
7

（9）a,b = 4,5，a *= b，a=?

a,b=4,5
a*=b
a

20

（10）int(3.14159)==float(3)会输出什么结果？为什么？type(int(3.14159))==type(float(3))的结果又是什么？

int(3.14159)==float(3)
print(float(3))
print(3.0==3)
type(int(3.14159))==type(float(3))

3.0
True





float

（2）列表，字典，集合

（1）L=[1,2,3,4,1,4,5,6],请完成：①删除列表中的重复元素并输出一个集合；②将7添加到集合中；③将集合转化为列表，删除元素3.

L=[1,2,3,4,1,4,5,6]
L=set(L)
print(L)
L.add(7)
print(L)
L=list(L)
# del L[3]#按照索引删除
# L.pop(3)#按照索引删除
L.remove(3)#按值删
print(L)
print(L.index(7))#获取索引

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7}
[1, 2, 4, 5, 6, 7]
5

（2）dog = [“tom”, “jack”, “Collie”, “Marry”], kitty = “Marry”, 如何判断 kitty 是否是 dog 中的一员?

dog = ["tom", "jack", "Collie", "Marry"]
kitty = "Marry"
if kitty in dog:
    print('YES')

YES

（3）dog = [“tom”, “jack”, “Collie”, “Marry”]，将dog逆序。

dog = ["tom", "jack", "Collie", "Marry"]
print(dog[::-1])
for i in reversed(dog):#不会改变副本
    print(i)
dog.reverse()
dog

['Marry', 'Collie', 'jack', 'tom']
Marry
Collie
jack
tom

['Marry', 'Collie', 'jack', 'tom']

（4）L=[“former”, “latter”, “starboard”]，请完成：为L在末端添加一个元素“port”。

L=["former", "latter", "starboard"]
L.append("port")
L

['former', 'latter', 'starboard', 'port']

（5）L=[1,2,3,1,5,11,3,6,4,2,5,8,4,2],计算L的最值，和加和。

L=[1,2,3,1,5,11,3,6,4,2,5,8,4,2]
print(max(L),'\n',sum(L))

11 
 57

（6）cube：length：40，width：40，height：40, 请创建一个字典，包括cube的所有信息，并向字典中添加条目“color”和对应值"red"，
删除属性height，修改属性width为20.

dic={"length":40,"width":40,"height":40}
dic["color"]="red"
print(dic)
dic["width"]=20
dic.pop("height")
print(dic)

{'length': 40, 'width': 40, 'height': 40, 'color': 'red'}
{'length': 40, 'width': 20, 'color': 'red'}

（7）set_a = {1, 5, 10} set_b = {1, 10, 12} 找出set_a和set_b中共有的元素（交集）。

set_a = {1, 5, 10}
set_b = {1, 10, 12}
print(set_a&set_b)

{1, 10}

（8）从1到10中选出所有的奇数。

[x for x in range(1,11) if x%2==1]

[1, 3, 5, 7, 9]

（9）将字典变为两个元素一一对应的列表，一个只含有关键字，另一个只含有值。 如:{‘a’: 1, ‘b’: 2}变为[‘a’, ‘b’], [1, 2]

dic={'a': 1, 'b': 2}
a=list(dic.keys())
b=list(dic.values())
c=list(dic.items())
print(a,b,c)

['a', 'b'] [1, 2] [('a', 1), ('b', 2)]

（3）条件判断，循环和函数

（1）L=[1,2,‘’,‘my’,3,‘name’,‘is’,4,‘katty’],利用循环语句和判断条件，分别输出列表中的字符串和数字。

L=[1,2,'','my',3,'name','is',4,'katty']
string=[]
num=[]
for i in L:
#     print(type(i))
    if str(type(i))=="":
        num.append(i)
    else:
        string.append(i)
print(string)
print(num)

['', 'my', 'name', 'is', 'katty']
[1, 2, 3, 4]

（2）利用循环语句输出1到50中5的倍数，将其存放到一个列表中。

[i for i in range(1,51) if i%5==0]

[5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

（3）定义一个判断字符串的长度是否大于10的函数。

def fun(string):
    return len(string)>10
s="4548404446648878877"
if fun(s):
    print("YES")

YES

（4）定义一个求解阶乘的函数。

def JC(a):
    return 1 if a==1 else a*JC(a-1)
#     if a==1:
#         return 1
#     else:
#         return a*JC(a-1)
print(JC(5))    

120

（5）利用列表生成式，生成1-5的阶乘。

[JC(i) for i in range(1,6)]

[1, 2, 6, 24, 120]

（6）利用函数和列表生成式，标记一个列表，奇数标记为1，偶数标记为2，并且统计一下奇数和偶数的数量。
例如：[1,4,2,4,2,9,5]，得到[1,2,2,2,2,1,1]

def fun(i):
    return 1 if i%2==1 else 2
L=[1,4,2,4,2,9,5]
l=[fun(i) for i in L]
print(l)
x=[i%2 for i in l]
print("有奇数{}个，偶数{}个".format(sum(x),len(x)-sum(x)))
# print(fun(3))

[1, 2, 2, 2, 2, 1, 1]
有奇数3个，偶数4个