list选取多个元素 python_【幼儿园级】0基础学python一本通（上）—

在未来面前，每个人都是学生

江海升月明，天涯共此时，关注江时！

引

子

本篇为AI未来系列第一篇。为什么要研究学习python？python是未来屠龙的屠龙宝刀，再辅助以我们的高中数学基础(足够用的屠龙术)，小白们即可把握人工智能的未来。本系列初步阶段主要攻克数据分析问题，中阶攻克爬虫问题，高阶进入人工智能阶段，顺带会穿插一些硬件知识。

想想比尔盖茨的发家史，也有点小小激动哟。未来已来，just do it。时不我待，今天是2019年2月12日农历初八，赶紧开始第一篇——幼儿园级，老妪也会，0基础学python一本通。

正

文

为什么Python这么受欢迎？

简单的来说，有下面五点原因：
1、Python可以在多种计算机操作系统中运行(Unix,Windows,MacOS,Ubuntu等等)，python在这些语言中是最简单易用的。
2、Python能够实现交互式命令输出。对于非专业程序员而言，都希望边编写程序，边查看结果。
3、Python是开源免费的，有很多强大易用的标准库。对于非专业的程序员而言，使用这些库可以免去自己编写的烦恼。
4、Python是一种解析性的、面向对象的编程语言。面向对象编程和一般的编程不太一样，有其自身的优势。
5、Python是可以连接多种语言的胶水语言。

Python与其他数据分析语言对比

一、Python基础语法

初次使用Python，首先要明确三点：

Python的标识符(例如变量名、函数名等)，可用字母、数字和下划线构成，不能以数字开头，且区分大小写。
Python对于缩进敏感。在Python中，是使用缩进来写代码块。
Python的注释语句一般用#开头。多行注释可以有用三引号。

'''
这里使用了多行注释
使用三引号将注释内容包含起来
在代码上中只能使用#开头的注释语句
'''
a = 1       #小写字母定义变量
A = 2       #大小字母定义变量
a1 = 3      #小写字母+数字 一起来定义变量
a_b_c = 4   #小写字母+下划线 来定义变量
_n_ = 5     #下划线+小写字母 来定义变量
print(a,A,a1,a_b_c,_n_)```

1 2 3 4 5

'''
使用缩进来说明代码块
下面编写了一个循环
注意到循环体N=N+n相对于之前的代码缩进了
因为它是整个循环的循环体，需要通过缩进标识出来
'''
N = 0
for n in [1,2,3,4,5]:
    N = N + n
print(N)

'''
删除某个对象
'''
x = 1
del x #删除对象x
x

二、Python基础数据类型

Python中基础的数据类型只有两类：字符串string和数字。在数字类型下，可细分为4个类型整型int、长整型long、浮点数float和复数complex。常用的数字类型为整型int和浮点数float。

2.1 字符串string

关于字符串，有下面三点需要注意。其中第三点尤为关键，且不光是针对字符串，对于python中所有的索引都是适用的。

1、Python用单引号''，双引号""，三引号''''''来标识字符串，三引号用于多行文本
2、字符串也是一个序列，可以截断和切片
3、注意python中的索引：从左到右索引默认从0开始，最大范围为字符串长度-1。从右向左索引默认从-1开始，最大范围是字符串开头

string = 'I love Wind!'

long_string = '''
I love Wind
and Wind welcomes everyone
We are a family
'''

# 上面定义两个字符串 其中 long_string为一个多行的字符串 所以用''''''包含起来
print(string)
print(long_string)
I love Wind!

I love Wind！

I love Wind

and Wind welcomes everyone
We are a family

print('字符串的第一个元素(注意索引为0)：          ',string[0])
print('字符串的倒数第一个元素(支持负索引)：       ',string[-1])
print('原字符串(注意空格也占据一个字符)：         ',string)
print('字符串索引2至5(注意索引的话左包含右不包含)：',string[2:6])
print('字符串索引2至最后：                       ',string[2:])
print('字符串索引-2至最后：                      ',string[-2:])

字符串的第一个元素(注意索引为0)： I
字符串的倒数第一个元素(支持负索引)： !
原字符串(注意空格也占据一个字符)： I love Wind!
字符串索引2至5(注意索引的话左包含右不包含)： love
字符串索引2至最后： love Wind!
字符串索引-2至最后： d!

'''
关于字符串的运算
'''
print('字符串重复2遍：',string * 2)
print('字符串的拼接：',string + ' and Wind welcomes everyone!')

字符串重复2遍： I love Wind!I love Wind!
字符串的拼接： I love Wind! and Wind welcomes everyone!

'''
\n可用来字符串的换行
'''
print('我想换行\n换行成功')

我想换行
换行成功

'''
\t可用来输入制表符
'''
print('我想插入一个制表符\t插入成功')

我想插入一个制表符插入成功

2.2 数字number

数字可以细分为四个类型，一般常用的是整形int和浮点数float。

x1 = 10 ; x2 = 2.23   #用分号;隔开 可以在一行中写多个语句
type(x1),type(x2)

(int, float)

三、Python数据集合类型

在基础数据类型的基础上，Python有6中数据集合的类型：

1、列表list，最常用的数据类型，以[]为标识
2、元组tuple，和list很相似，但是不能二次赋值，用()标识
3、集合set，和list类似，但是set中没有重复的元素，常用于集合间的运算，用{}标识
4、字典dict，无序的对象集合，字典中的元素通过关键词key来调用，同样以{}来标识
5、数组array，科学计算和代数运算常用的数据类型，在后续numpy库系列详细说明
6、数据框dataframe，数据分析处理常用的数据类型，在后续pandas库系列详细说明

3.1 列表list

print('这里定义了一个列表list——x1，注意到列表x1中的元素是可以不同的，这里由两个数字1和2，一个字符串James，一个列表[1,2,3]这四个元素构成了x1这个列表list。')
x1 = [1,2, 'James', [1,2,3]]
print(x1)

这里定义了一个列表list——x1，注意到列表x1中的元素是可以不同的，这里由两个数字1和2，一个字符串James，一个列表[1,2,3]这四个元素构成了x1这个列表list。
[1, 2, 'James', [1, 2, 3]]

print('如何来调用列表x1中的某个或者某几个元素呢？？\n')   #这里的\n的含义是空一行
print('调用列表x1的第一个元素(注意第一个元素的索引为0)：',x1[0])
print('调用列表x1的最后一个元素(注意最后一个元素的索引为-1)：',x1[-1])
print('调用列表x1的前2个元素(注意索引的时候右不包含)：',x1[:2])

如何来调用列表x1中的某个或者某几个元素呢？？

调用列表x1的第一个元素(注意第一个元素的索引为0)： 1
调用列表x1的最后一个元素(注意最后一个元素的索引为-1)： [1, 2, 3]
调用列表x1的前2个元素(注意索引的时候右不包含)： [1, 2]这里要说明的是，python下序列(例如数组，列表，元组等)的索引，是从0开始而非从1开始。从左到右索引默认从0开始，从右到左索引默认从-1开始。
一般索引的方式为序列[索引开始：索引结尾]，且要注意python索引是右不包含，即索引结尾对应的元素是不包含在结果中的。

print('关于列表的运算\n')
x2 = ['a','b','c']
print('将两个列表x1和x2拼接起来',x1+x2)
x1.append('新增元素')
print('在列表x1中添加一个元素',x1)
print('将列表x2重复两遍',x2*2)

关于列表的运算

将两个列表x1和x2拼接起来 [1, 2, 'James', [1, 2, 3], 'a', 'b', 'c']
在列表x1中添加一个元素 [1, 2, 'James', [1, 2, 3], '新增元素']
将列表x2重复两遍 ['a', 'b', 'c', 'a', 'b', 'c']

'''
append是在列表的末尾添加元素，那如果要在列表中间添加元素怎么做呢？
'''
print('原列表：',x1)
x1.insert(2,1000)
print('在索引2位置添加了新的元素：',x1)

原列表： [1, 2, 'James', [1, 2, 3], '新增元素']
在索引2位置添加了新的元素： [1, 2, 1000, 'James', [1, 2, 3], '新增元素']

'''
根据索引来删除列表中的元素
'''
print('原列表：',x1)
x1.pop(3)
print('删除索引3上的元素后：',x1)

原列表： [1, 2, 1000, 'James', [1, 2, 3], '新增元素']
删除索引3上的元素后： [1, 2, 1000, [1, 2, 3], '新增元素']

'''
在列表中添加多个元素
'''
print('原列表：',x1)
x1.extend([0,1,2,3,4,5,6])
print('添加多个元素后：',x1)

原列表： [1, 2, 1000, [1, 2, 3], '新增元素']
添加多个元素后： [1, 2, 1000, [1, 2, 3], '新增元素', 0, 1, 2, 3, 4, 5, 6]

'''
根据元素值来删除元素
'''
print('原列表：',x1)
x1.remove('新增元素')
print('删除"新增元素"元素后：',x1)

原列表： [1, 2, 1000, [1, 2, 3], '新增元素', 0, 1, 2, 3, 4, 5, 6]
删除"新增元素"元素后： [1, 2, 1000, [1, 2, 3], 0, 1, 2, 3, 4, 5, 6]

x2 = [1,1,1,1,2,2,2,3,43,4,5,6,4]
print('查看元素1在列表中出现的次数：',x2.count(1))

查看元素1在列表中出现的次数： 4

print('关于列表的排序\n')
x3 = [-10,-2,1,-100,333,1000]
print('原列表：',x3)
x3.sort()
print('按从小到大排序：',x3)
x3.sort(reverse=True)
print('按从大到小排序：',x3)

关于列表的排序

原列表： [-10, -2, 1, -100, 333, 1000]
按从小到大排序： [-100, -10, -2, 1, 333, 1000]
按从大到小排序： [1000, 333, 1, -2, -10, -100]

3.2 元组tuple

x3 = (66.6,'万得资讯',1.0000)
print('这是一个元组tuple：',x3)
x3[0] = 1

这是一个元组tuple： (66.6, '万得资讯', 1.0)

print('关于元组tuple的相关计算：')
print(x3 + ('a','b'))
print(x3 * 2)
#从结果可以发现，元组的一些计算和列表list是类似的

关于元组tuple的相关计算：
(66.6, '万得资讯', 1.0, 'a', 'b')
(66.6, '万得资讯', 1.0, 66.6, '万得资讯', 1.0)
可以发现，当想对一个元组tuple的第一个元素(索引0)重新赋值时，则会报错。说明元组一旦定义好了就不能二次赋值了。但是要注意如下这种情况

x4 = ('jack',1000,[1,2,3])
x4[2][1] = 1000
x4

('jack', 1000, [1, 1000, 3])
在x4这个元组中，索引2对应的元素是一个列表[1,2,3]，那么这个列表中的元素做一个更改的话是可以的

3.3 集合set

x0 = [1,1,2,2,3,3,4,4,5,5]
print('含有重复元素的一个列表x0：',x0)
x0_set = set(x0)
print('将列表x0转化一个集合：',x0_set)
print('可以发现集合x0_set中没有重复的元素')

含有重复元素的一个列表x0： [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
将列表x0转化一个集合： {1, 2, 3, 4, 5}
可以发现集合x0_set中没有重复的元素

print('关于集合set的计算')
set1 = {1,2,3,4,5}
set2 = {2,3,4}
print('集合set1：',set1,'\n','集合set2：',set2)
print('集合set1和集合set2的差集：',set1-set2)
print('集合set1和集合set2的交集：',set1.intersection(set2))

关于集合set的计算
集合set1： {1, 2, 3, 4, 5}
集合set2： {2, 3, 4}
集合set1和集合set2的差集： {1, 5}
集合set1和集合set2的交集： {2, 3, 4}

print('集合set1：',set1,'\n','集合set2：',set2)
print('集合set1和集合set2的交集：',set1&set2)
print('集合set1和集合set2的并集：',set1|set2)

集合set1： {1, 2, 3, 4, 5}
集合set2： {2, 3, 4}
集合set1和集合set2的交集： {2, 3, 4}
集合set1和集合set2的并集： {1, 2, 3, 4, 5}

3.4 字典dict

# 字典定义方式一
dict1 = {}  #先创建一个空字典
dict1['姓名'] = '万矿'
dict1['年龄'] =  0.5
dict1['能力值'] = 1000
print(dict1)
# 字典定义方式二
dict2 = {'姓名':'Kobe Bryant','身高':198,'冠军数':5}
print(dict2)

{'能力值': 1000, '年龄': 0.5, '姓名': '万矿'}
{'身高': 198, '冠军数': 5, '姓名': 'Kobe Bryant'}

# 字典定义方式三
dict3 = dict.fromkeys(['A','B','C'],1000)
print(dict3)
# 字典定义方式四
dict4 = dict(zip(['A','B','C'],[1,10,100]))
print(dict4)

{'B': 1000, 'A': 1000, 'C': 1000}
{'B': 10, 'A': 1, 'C': 100}

print('字典由关键词key和值value两个部分构成')
print('查看字典dict2的关键词：',dict2.keys())
print('查看字典dict2的值：',dict2.values())

字典由关键词key和值value两个部分构成
查看字典dict2的关键词： dict_keys(['身高', '冠军数', '姓名'])
查看字典dict2的值： dict_values([198, 5, 'Kobe Bryant'])

'''
删除字典中的关键词
'''
dict1.pop('姓名')
print('删除关键词“姓名”：',dict1)

删除关键词“姓名”： {'能力值': 1000, '年龄': 0.5}

dict1.clear()
print('清除字典中的所有元素：',dict1)

清除字典中的所有元素： {}

四、Python基本运算符

五、条件和循环

5.1条件语句

条件语句基本框架如下：if 判断语句1:执行语句块1elif 判断语句2:执行语句块2else:执行语句块3

a = 10
2
if a%2 == 0 :     #这里使用了取余函数%
3
    print(a,'是偶数')
4
else:
5
    print(a,'是奇数')

10 是偶数

b = '张三'
2
if b in ['张一','张二','张三','张四']:  #这里使用了in来判断
3
    print(b,'是张家人')
4
else:
5
    print(b,'不是张家人')

张三是张家人

c = 20
2
if c 3
    print(c,'小于20')
4
elif c > 80:
5
    print(c,'大于80')
6
else:
7
    print(c,'在20~80之间')

20 在20~80之间

5.2 循环语句

5.2.1 for循环

1
sum = 0  #实现0+1+2+。。+9
2
for j in range(10):
3
    sum = sum + j
4
print(sum)

1
sum = 0
2
for j in range(10):
3
    sum += j   #这句和 sum = sum + j一个效果
4
print(sum)

5.2.2 while循环

j = 1
2
while j != 6:
3
    j = j + 1
4
print('循环结果为：',j)

循环结果为： 6

5.2.3 循环控制语句——break

break语句的含义是终止当前循环，且跳出整个循环

for j in range(10):
2
    if j == 6:
3
        break
4
    print('当前j的值为：',j)

当前j的值为： 0
当前j的值为： 1
当前j的值为： 2
当前j的值为： 3
当前j的值为： 4
当前j的值为： 5

5.2.4 循环控制语句——continue

continue语句的含义是终止当次循环，跳出该次循环，直接执行下一次循环

for j in range(10):
2
    if j == 6:
3
        continue
4
    print('当前j的值为：',j)

当前j的值为： 0
当前j的值为： 1
当前j的值为： 2
当前j的值为： 3
当前j的值为： 4
当前j的值为： 5
当前j的值为： 7
当前j的值为： 8
当前j的值为： 9

5.2.5 pass语句

当执行到pass语句时，其含义就是不执行任何操作

for j in range(10):
2
    if j == 6:
3
        pass
4
    else:
5
        print('当前j的值为：',j)

当前j的值为： 0
当前j的值为： 1
当前j的值为： 2
当前j的值为： 3
当前j的值为： 4
当前j的值为： 5
当前j的值为： 7
当前j的值为： 8
当前j的值为： 9

5.2.6 循环、条件嵌套

例如我们要寻找2-100中的所有素数，本身需要一个循环。而判断某一个数是否为素数也需要一个循环，所以这里嵌套了两个循环。循环中还有一些条件语句。

#寻找2-100中的所有素数
2
num = []  #这里创建一个空列表是为了存储结果
3
for i in range(2,100):
4
    j = 2
5
    while j <= i/j : 
6
        if i%j == 0: #%指计算余数
7
            break
8
        j = j + 1
9
    if j > i/j:
10
        num.append(i)
11
print(num)