python列表

python数据类型（二）

被刻印的时光ゝ — Tue, 07 Apr 2020 07:17:41 +0000

python数据类型（二）被刻印的时光ゝ 2020-04-07 15:17:41

python基础---数据类型（二）

回顾和补充

编译型语言和解释性语言？
- 解释性语言：代码逐句转化执行，代表语言：（python，PHP，，，，等等）
- 编译型语言：代码全部转化，然后全部执行代表语言：（C,C++,JAVA,C#,go，，，，等等）
str独有功能
- 补充：
  - .startswith(“ss”)判断是否以ss这个开头
  - .endswith（）判断是否以什么结尾
```
name=sse
fd=name.startswith("ss")   判断name是否以ss开头
fs=name.endswith（"e"）     判断是否以e结尾
```
  - .format（）占位符
```
name = "我叫{0}，年龄：{1}".format("老男孩",66,)
```
  - .encode()把unicode转换为指定的编码格式编码字符串
```
vl = name.encode.(utf8)
v2 = name.encode.("gbk")
```
  - ”_“.join() 循环每个元素并在每个元素之间加入连接符

公用功能

步长[0:-1：2]

name = "alexalex"
vl = name[0:-1:2]                 得到结果aeae
vl = name[1:-1:2]                 得到结果lxl
vl = name[1::2]                   得到结果lxlx
vl = name[::2]                    得到结果aeae
vl = name[-1:0:-2]                得到结果xlxl
vl = name[::-1]                   得到结果xelaxela

for循环语句

name = "alex"                     for循环基本结构
for item in name:                 每次给item赋值
    print(item)                   输出结果a l e x
break                             打断本次循环
continue                          跳出回到判断原点
range（0，10）                     生成0到9，前取后不取
建议以后做循环优先看能不能使用for循环，看有没有穷尽，无穷尽用whlif

今日内容

1.列表

users = ["lizs","liuya",99]         列表里面逗号分割元素

公用功能

len

users = ["lizs","liuya",99] 
sd = len(users)
print(sd)

索引

users = ["lizs","liuya",99] 
sd = users[0]                    取出lizs

切片

users = ["lizs","liuya",99] 
sd = users[0:2]                    取出lizs，liuya

步长

users = ["lizs","liuya",99]
sd = [0:-1:1]                  取出lizs，liuya

删除
```
user = ["sss","lll"]
del user[1]                  
```
- 注意：字符串本身不能修改或者删除
- 列表是可变类型

修改

user = ["sss","lll"]
user[1] = 66                  lll变成66

独有功能

.append() 将输入的东西加入列表

user = []
whlif Ture:
    user.append(name)             将用户输入的东西追加进列表
    print(user)

.insert() 插入

user=["sss","fff","eee"]
user.insert(1,"hz")                  在指定索引位置插入

.remove() 删除元素 / .pop 删除索引位置

user=["sss","fff","eee"]
user.remove("sss")              删除sss
user.pop[0]                     删除sss
user.pop[]           删除不写位置 默认删除最后一个

.clera() 删除列表

user=["sss","fff","eee"]
user.clera()                    删除列表

总结：
- 增：
  - append/insert
- 删：
  - remove/pop/clear/del
- 改
  - user[3]="新增"
- 查
  - 索引/切片

列表嵌套

user = [['sss','ssss','sssss',]['ddd','fff']]

2.元组

1.元组的书写规范

yuanzu = [111,222,333,"shan"]            列表
yuanzu = (111,222,333,"shan")            元组

注意：元组为不可变类型
有了列表为什么要选择元组，元组为了满足但凡创建就不能修改
元组中的元素不可以删除

公共功能：

可以使用的功能，与列表类似

索引
切片
步长
for循环
len

元组可以嵌套

独有功能（真tm惨，没有自己功能

来源：https://www.cnblogs.com/ffmmxx/p/10635789.html

标签

python for循环

python列表

python

Python-字符串及列表操作-Day2

a 夏天 — Tue, 07 Apr 2020 03:36:39 +0000

Python-字符串及列表操作-Day2 a 夏天 2020-04-07 11:36:39

1.数据类型

1.1 变量引出数据类型

变量：用来记录状态
变量值的变化就是状态的变化，程序运行的本质就是来处理一系列的变化

1.2 五大基本数据类型：

数字
字符串
列表
元组
字典

1.2.1 数字

    二进制：0101010     #对应的调用bin()
    八进制：1-7         #对应的调用oct()   
    十六进制：0-9abcdef #对应的调用hex()

整型
长整型
浮点
布尔
复数

1.2.2 整型

内置函数是：int()
int(a,base=b)
a是变量或者是"a(未定义变量)"
base=b b告诉计算机以什么进制进行运算
一切皆对象
age = 10 ---> int(10)--->init --->调用
以上说明所有的变量最终都是通过对象来生成创建的
python3中int()已经没有区分整型与长整型

1.2.3 布尔

True 和 False
1和0

1.2.4 浮点float

Python的浮点数就是数学中的小数

1.2.5 复数

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注意，虚数部分的字母j大小写都可以，

1.3 + 2.5j == 1.3 + 2.5J
True

1.3 字符串

字符串的定义：
msg="hello world"

1.3.1 字符串模块方法1：

#首字母大写:
print(msg.capitalize())

#按照字符串是20个 居中显示
print(msg.center(20,'*'))

#字符串中包含所选字符的计数 模式=（'字符',start=1,end=2） 
print(msg.count('l',1,3))
其中包含所选的字符是通过start和end字符位置确定的

#按照字符提取，[]内数字代表字符串的字符下标
print(msg[4])

#判断一个字符串是否是以'd'结尾的
print(msg.endswith('d'))

#指定空格的个数 expandtabs只是针对tab键或者空格键
msg1='a\tb'#\t
print(msg1)
print(msg1.expandtabs(10))

#找到对应字符的索引
print(msg.find('d'))

#没有找到就直接输出-1
print(msg.find('z'))
print(msg.find('d',1,11))

print('{0},{1}'.format('name','age'))
print('{name}'.format(name = "stone"))

1.3.2 字符串模块方法2：

index
索引：查看指定字符的索引

isalnum：  
判断字符都是数字

msg3='123a'   
isalpha：  
字符都是字母

isdecimal:  
判断是否是十进制数字

## isdigit(): ## 
判断是否是整型数字

isnumeric：  
判断是不是数字  

isidentifier:  
判断字符串内是否包含关键字;

islower():  
判断字符串是否是小写 

isspace():  
判断字符串是否是空格

istitle():   
是否是标题 单词首字母必须是大写的 其他的字符不能是大写的，

isupper():  
是否都是大写

lhust():   
左对齐  
print(msg.ljust(10,'*'))

rjust():  
右对齐

lower():  
将所有的大写转换成小写

upper():  
将所有的小写转换成大写

lstrip():  
左边去除空格

rstrip():  
去除右边的空格

maketrans():  
将字符串进行替换 替换的字符串需要跟等长

yfill():  
从右侧填充

1.3.3 字符串常用的操作

移除空白 strip()：去除空白
分割 split()
长度 len()
索引 msg[3]:字符索引
切片 msg[0:3]:字符串切片 msg[2:7:2]:按步长取

2. 运算符

2.1 算数运算

2.2 比较运算

2.3 赋值运算

2.4 位运算

注： ~ 举例： ~5 = -6 解释：将二进制数+1之后乘以-1，即~x = -(x+1)，-(101 + 1) = -110

按位反转仅能用在数字前面。所以写成 3+~5 可以得到结果-3，写成3~5就出错了

2.5 逻辑运算

and注解：

在Python 中，and 和 or 执行布尔逻辑演算，如你所期待的一样，
但是它们并不返回布尔值；而是，返回它们实际进行比较的值之一。  
在布尔上下文中从左到右演算表达式的值，如果布尔上下文中的所有
值都为真，那么 and 返回最后一个值。  
如果布尔上下文中的某个值为假，则 and 返回第一个假值

or注解：

使用 or 时，在布尔上下文中从左到右演算值，就像 and 一样。
如果有一个值为真，or 立刻返回该值
如果所有的值都为假，or 返回最后一个假值
注意 or 在布尔上下文中会一直进行表达式演算直到找到第一个
真值，然后就会忽略剩余的比较值

and-or结合使用：

结合了前面的两种语法，推理即可。
为加强程序可读性，最好与括号连用，例如：

（1 and 'x') or 'y'

2.6 成员运算

2.7 身份运算

3. for循环

写程序最忌讳的就是重复代码！！！

循环10次：

for i in range(10):
    print(i)
run执行输出：0 1 2 3 4 5 6 7 8 9 0

如果不想从0开始执行：

for i in range(1,10):
    print(i)   
run 执行结果：1 2 3 4 5 .. 9
range（1,10）：表示从1开始一直到9；
range（2，7）：表示从2开始一直到6；

3.1 猜年龄程序：

#!/usr/bin/env python
right_age = 60
for i in  range(3):
    age = int(input("print you guess age:"))
    if age == right_age:
        print("guess right!")
        break
    elif age > right_age:
        print("guess smaller!")
    else:
        print("guess bigger!")
else: #如果for循环正常结束，就执行下面的语句
    print("too many times!!!") # == exit("too many attempts")

3.2 for循环else语法测试：

for i  in range(10):
    print(i)
    if i == 5:
        print("5退出！")
        break
else:
    print("循环正常退出！")

执行结果

3.3 for循环-嵌套循环：

for i in range(10):
    print(i)
    for j in range(10):
        if j < 6:
            #break # 跳出当前层循环
            continue #跳出当次循环，继续下一次循环
        print(i,j)

3.4 while 循环

死循环
判断年龄，使用while+条件执行循环。

#!/usr/bin/env python
age=56
count = 0      # 计数
while count<3: # 判断执行三次跳出loop
    guess = input("guess age:")
    if guess.isdigit():
        guess = int(guess)
    else:
        continue
    if guess == 56:
        print("OK")
        break
    elif guess > age:
        print("bigger")
    else:
        print("smaller")
    count += 1

4. 列表

4.1 列表功能

定义一个列表：names = []

或者name = list(1,2,4)

names = []最终调用的就是list这个类

4.1.1 增 append

names.append()

例子：names.append("zheng")  
print(names)  
names.insert(2,"app")在指定的index之前插入

4.1.2 删 del pop() remove()

删除的三种方式：

names.remove()

names.pop()

del names[index]

names.remove("app"):删除找到的第一个key  
del names[3]:直接指定索引删除  
names.pop(3):指定索引删除，不指定索引直接删除最后一个。

4.1.3 改

names[1] = "wang" 直接指定索引替换成想要的  
print(names)

4.1.4 查

print(name[-2])        #直接指定索引取出  
print(name[0::2])       #按照步长取值  
print(name[-3:])        #取最后三个元素  
print(name[:3])         #取前三个元素  
print(name.index("wang"))#取元素的下标

4.1.5 计数 count()

print("count",names.count("wang"))# 获取

4.1.6 清空 clear()

name.clear()            #清空列表

4.1.7 扩展合并 extend()

name.extend("liang")    #作用是两个列表的合并  
name1=["hello","nihao"]  
name2=["ca","haha"]  
name1.extend(name2)     #列表扩展  
name1  
['hello', 'nihao', 'ca', 'haha']

4.1.8 排序 sort()

name.sort() #排序

4.1.9 反转 reverse()

name.reverse()          #反转  
python3中列表中必须统一 元素中字符串与数字不能混用

4.1.10 copy()

copy语法重新制定内存与原内容内存id存储位置不同

4.1.11 列表的长度len()

name = [11,22,33]
print(len(name))
3

4.3 循环一个列表

for i in names:
    print(i)
enunerate(name):

4.4 列表的判断

len(a)
# 判断一个列表的长度
val >=0 and val <len(a)

4.5 数据类型转换内置函数汇总

5 Python整理-小记

5.1 执行脚本传入参数

Python有大量的模块，从而使得开发Python程序非常简洁。类库有包括三中：

Python内部提供的模块
业内开源的模块
程序员自己开发的模块

Python内部提供一个 sys 的模块，其中的 sys.argv 用来捕获执行执行python脚本时传入的参数

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
 
print sys.argv

5.2 sys os 模块小记

Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，以后的课程中会深入讲解常用到的各种库，现在，我们先来象征性的学2个简单的。

5.2.1 sys 模块

sys 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
print(sys.argv)

#输出
$ python test.py helo world
['test.py', 'helo', 'world']  #把执行脚本时传递的参数获取到了

5.2.2 os模块

os
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import os
 
os.system("df -h") #调用系统命令

5.2.3 完全结合一下　　

import os,sys
 
os.system(''.join(sys.argv[1:])) #把用户的输入的参数当作一条命令交给os.system来执行

来源：https://www.cnblogs.com/lincappu/p/8157504.html

标签

Python学习笔记二——数据类型及数据操作

给你一囗甜甜゛ — Mon, 06 Apr 2020 21:36:11 +0000

Python学习笔记二——数据类型及数据操作给你一囗甜甜゛ 2020-04-07 05:36:11

概要：

基本语法

输出格式、变量、注释

数据类型

Numbers (数字)、String (字符串)、List (列表)、Tuple(元组)、Cictionary(字典) 及各个数据类型的常用方法和内置函数、多维数组等

数据操作

切片操作、回文算法

基本语法 -

输出格式：

Python的输出语法和Swift的输出一样

1 # 输出
2 print("Hello Python")

注释：

Python中单行注释采用 # 开头。

python中多行注释使用三个单引号 ''' 或三个双引号 """

变量：

Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

Python允许你同时为多个变量赋值, 也可以为多个对象指定多个变量。例如：

1 a = b = c = 1 
2 
3 # 多变量赋值
4 a, b, c = 1, 2, "jun"

标准数据类型

有五个标准的数据类型：

Numbers (数字)

String (字符串)

List (列表)

Tuple(元组)

Cictionary(字典)

Number（数字）

Number是不可被改变的数据类型, 当你指定一个值时，Number对象就会被创建

Python支持四种不同的数值类型：

int （有符号整型）

long （长整型[也可以代表八进制和十六进制]）

float （浮点型）

complex （复数）

复数: 和数学中的复数含义一样, 复数由实数部分和虚数部分构成，可以用a+bj, 或者complex（a,b）表示，复数的实部a和虚部b都是浮点型

字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符
Swift中的字符串一样, 每一个字符都有一个与之对应的索引
Python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
获取某一部分字符串的格式: [头下标:尾下标]

 1     字符串的常用方法
 2         s='aNc'
 3         q='1+2+3\n1+2+3+4'
 4         a='mysql is is db'
 5         s.find('z')) # 找不存在的元素，find会返回-1
 6         s.index('z')   #  找不存在的元素，index报错
 7         s.count('z')  # 计数
 8         a.rfind('db'))#返回最右边字符的下标
 9         s.upper()   # #变成大写
10         s.lower()   #变成小写
11         s.swapcase())#大小写反转
12         s.capitalize() #首字母大写
13         s.split(',')   # 以，位分隔符，返回list
14         q.splitlines()#按照换行符分割
15         s.strip('abc') #去除“abc”
16         s.lstrip()   ##默认去掉左边的空格和换行
17         s.rstrip()    ##默认去掉右边的空格和换行
18         s.replace('old','new')  # 替换
19         s.endswith('xxx.mp3')     #判断时候xxx.mp3结尾
20         s.startswith('186')    #判断时候186开头
21         s1=','.join(list)    #1、把list变成了字符串 2、把list里面每一个元素用逗号连接起来                                             username,user2,user3
22         print('+'.join(['hehe', 'haha', 'ee']))  # 拼接字符串     hehe+haha+ee
23         s.isdigits()  ##判断是否为正整数
24         s.isalpha() #是否是英文字母
25         s.isalnum()  #是否包含数字和字母
26         s.zfill(5)  # 位数不足5位时，自动补零
27         s.isidentifier())#是否是一个合法的变量名
28         s.istitle())#是不是一个标题，判断首字母是否大写
29         s.isidentifier())#是否是一个合法的变量名
30         a.rfind('is')#返回最右边字符的下标

 1 # 字符串
 2 str = 'Hello Python'
 3 
 4 # 1. 输出完整字符串
 5 print("完整字符串--" + str)
 6 # 结果输出:
 7 
 8 # 2. 输出第一个字符
 9 print("第一个字符--" + str[0])
10 
11 # 3. 输出第三到七个字符
12 print("第3-7个字符--" + str[2:6])
13 
14 # 4. 输出低2个字符开始的所有字符
15 print("第2个开始的所有字符--" + str[1:])
16 
17 # 5. 拼接字符串
18 # 像上面一样, 字符串用 `+`拼接
19 print("拼接--" + str)
20 
21 # 6. 输出3次
22 # `*` 表示重复操作, 需要重复操作几次, 后面跟上次数即可
23 print(str * 3)
24 
25 # 7. 输出最后一个字符
26 print("最后一个字符--" + str[-1])
27 
28 # 8. 输出倒数第二个字符
29 print("倒数第二个字符--" + str[-2])

# 输出结果

 1 
 2 完整字符串--Hello Python
 3 第一个字符--H
 4 第3-7个字符--llo 
 5 第2个开始的所有字符--ello Python
 6 拼接--Hello Python
 7 Hello PythonHello PythonHello Python
 8 最后一个字符--n
 9 倒数第二个字符--o
10

一些方法：

 1 password='jpg 12345456789 .jpg ABCDE'
 2 print(password)    # 输出结果 ：jpg 12345456789 .jpg ABCDE   new_password = password.strip()  # 默认去掉字符串两边的空格

new_password = password.strip('\n')  # 默认去掉字符串两边换行符

 3 new_password = password.strip('.jpg') # 默认去掉字符串两边的指定去掉字符串  4 print(password.lstrip()) # 左边的  5 print(password.rstrip()) # 右边的  6 print('password',password)  7 print('newpassword',new_password)  8 print(password.upper()) # 转成大写的  9 print(password.lower()) # 转成小写的 10 print(password.capitalize()) # 吧首字母改成大写的 11 print(password.count('jpg')) # 计算指定字符的在字符串中的次数 12 print(password.replace('爱玲','上山打老虎')) # 替换字符串

1 filename = 'a.mp4'
2 age=18
3 print(filename.endswith('.mp3'))  # 判断是否以xx结尾  # 输出 ： False
4 print(filename.startswith('18'))  # 判断是否以开头    # 输出 ：True
5 print('{name},{age}'.format(name='hhh',age=age))  # 字符串格式化   # 输出 ： hhh，18

1 names = '小军 海龙 杨帆     爱玲'
2 print(names.replace(' ',''))  # 把name中的空格替换掉
3 print(names.split(' '))        # 以 空格 作为分割符 进行分割，分割后的每个元素组成一个list
4 # 1、是把字符串变成list
5 # 2、以某个字符串分割，分割之后的是list里面的每一个元素

List（列表）

List（列表）是 Python 中使用最频繁的数据类型, 和C语言中的数组一样, 语法操作和上述字符串类似
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识。是python最通用的复合数据类型

从左到右索引默认0开始的
从右到左索引默认-1开始
下标可以为空表示取到头或尾。

加号（+）是列表连接运算符，星号（*）是重复操作

 1 # List 列表
 2 list1 = [12, 34, 3.14, 5.3, 'titan']
 3 list2 = [10, 'jun']
 4 
 5 # 1.完整列表
 6 print(list1)
 7 
 8 # 2.列表第一个元素
 9 print(list1[0])
10 
11 # 3.获取第2-3个元素
12 print(list1[1:2])
13 
14 # 4.获取第三个到最后的所有元素
15 print(list1[2:])
16 
17 # 5.获取最后一个元素
18 print(list1[-1])
19 
20 # 6.获取倒数第二个元素
21 print(list1[-2])
22 
23 # 7.获取最后三个元素
24 print(list1[-3:-1])
25 
26 # 8.合并列表
27 print(list1 + list2)
28 
29 # 9.重复操作两次
30 print(list2 * 2)

1、增加列表元素：A、list.append()B、list.insert()

1 # 增加列表元素
2 stu_name = ['哈华','呢呢','心',1,1.5]
3 print(stu_name)
4 stu_name.append('小月')  # 在list的末尾添加一个元素
5 stu_name.insert(0,'小军')  # 指定位置添加元素
6 stu_name.insert(0,'小军')  # 指定位置再添加元素
7 print('修改之后的',stu_name)

输出结果：

1 ['哈华', '呢呢', '心', 1, 1.5]
2 修改之后的 ['小军', '小军', '哈华', '呢呢', '心', 1, 1.5, '小月']

2、修改列表元素

1 # 修改列表元素
2 stu_name = ['哈华','呢呢','心',1,1.5,'强']
3 stu_name[5]='花花'
4 print('修改之后的',stu_name) 
5 
6 # 输出结果 ：
7 
8 修改之后的 ['哈华', '呢呢', '心', 1, 1.5, '花花']

3、删除列表元素 ：A、list.pop()

#没有下标，删除最后一个元素

若删除指定下标的元素,删除不存在的元素会报错

B、del list[1] :

# 下标、索引、如果是正数就从左边开始算起，如果是负数，则从后面开始数起，倒序

C、list.remove('')   #删除指定的元素，如果有一样的元素，只会删除第一个

# 删
stu_name = ['哈华','呢呢','心',1,1.5,'强']

stu_name.pop()  # 删除最后一个元素
stu_name.pop(4)  # 删除指定下标的元素
print("删除后：",stu_name)

# 输出结果 ：

删除后： ['哈华', '呢呢', '心', 1]

 1 # 删
 2 stu_name = ['哈华','呢呢','心',1,1.5,'强' ,'小军']
 3 
 4 # stu_name.pop()  # 删除最后一个元素
 5 # stu_name.pop(4)  # 删除指定下标的元素
 6 # print("删除后：",stu_name)
 7 stu_name.append('小军')  # 先增加一个小军
 8 print(stu_name)
 9 stu_name.remove('小军')  # 删除指定的元素，如果有一样的元素，只会删除第一个
10 stu_name.pop(1)  # 删除指定下标的元素,删除不存在的元素会报错
11 print(stu_name)
12 del stu_name[-1]  # 下标、索引、如果是正数就从左边开始算起，如果是负数，则从后面开始数起，倒序
13 print(stu_name)
14 
15 
16 #输出结果 ：
17 ['哈华', '呢呢', '心', 1, 1.5, '强', '小军', '小军']
18 ['哈华', '心', 1, 1.5, '强', '小军']
19 ['哈华', '心', 1, 1.5, '强']

4、查询列表元素：

 1 #  查
 2 my_list = ['小黑','小白',1,1,2,1.5]
 3 print(my_list[-1])
 4 print(my_list[0])
 5 print(my_list.count(5))     # 查询某个元素在list里面出现的次数
 6 print('index方法：',my_list.index(1))     # 查找元素的下标，元素不存在的话，会报错
 7 print('reverse:',my_list.reverse())     # reverse是反转list
 8 print(my_list)
 9 # my_list.clear()#清空整个list
10 # print(my_list)
11 
12 nums =[9.23,9,3,6,1,0]
13 nums.sort() # 排序，升序
14 nums.sort(reverse=True)    # 排序,如果指定了reverse=True，那么就是降序
15 # nums.extend(my_list)#把一个list里面的元素加入进去
16 print(nums)
17 new_list = nums + my_list + stu_name
18 # extend是把列表本身变化了，而直接
19 # 两个列表相加的话，列表本身没有变化，只是相加的结果存在一个新的列表里面
20 print(new_list)
21 print(new_list * 3)    # 复制几个

列表函数和方法：

 1 函数表达式                   输出结果                描述
 2 len(list1)                   3                  列表元素个数
 3 max([1, 2, 's'])             s                  返回列表元素的最大值
 4 min([1, 2, 's'])             1                  返回列表元素的最小值
 5 list(('q', 1)             ['q', 1]              将元组转换为列表
 6 list1.append(2)           [1, 2, 3, 2]          在列表末尾添加新的对象
 7 list1.count(2)               2                  统计某个元素在列表中出现的次数
 8 list1.index(3)               2                  从列表中找出某个值第一个匹配项的索引位置
 9 list1.insert(1, 'jun')    [1, 'jun', 2, 3, 2]   将对象插入列表的指定位置
10 list1.remove(3)         [1, 'jun', 2, 2]        移除列表中某个值的第一个匹配项
11 list1.reverse()         [2, 2, 'jun', 1]        对列表的元素进行反向排列
12 list1.sort()            [2, 2, 'jun', 1]         对原列表进行排序, 如果指定参数，则使用比较函数指定的比较函数

extend()方法

用于在列表末尾一次性追加另一个序列(元组和列表)中的多个值（用新列表扩展原来的列表）

1 list3 = [12, 'as', 45]
2 list4 = (23, 'ed')
3 list3.extend(list4)
4 print(list3)
5 
6 //输出:
7 [12, 'as', 45, 23, 'ed']

len( ) : 取长度

1 passwords=['123456','123123','7891234','password']
2 print(len(passwords))  # 取长度，也就是list里面元素的个数 
3 
4 # 输出结果 
5 4

多维数组：

 1 nums1 = [1,2,3]  # 一维数组
 2 nums2 = [1,2,3,[4,56]]  # 二维数组
 3 print(nums2[-1][-1])
 4 
 5 # 多维数组
 6 
 7 nums = [1,2,3,4,['a','b','c','d','e',['一','二','三']],['四','五']]  # 三维数组
 8 nums3 = [1,2,3,4,['a','b','c','d','e',['一','二','三',[1,2,3]]]]  # 四维数组
 9 print(nums[4][5][1])
10 
11 # 输出结果
12 56
13 二

循环List ：

 1 # 循环这个list 
 2 # 原始方式
 3 passwords=['123456','123123','7891234','password']
 4 
 5 count = 0  # 最原始list取值方式，是通过每次计算下标来获取元素的
 6 while count<len(passwords):
 7     s = passwords[count]
 8     print('每次循环的时候',s)
 9     count+=1
10 
11 # 输出结果 ：
12 每次循环的时候 123456
13 每次循环的时候 123123
14 每次循环的时候 7891234
15 每次循环的时候 password
16 
17 
18 
19 #  简单方式 用for循环 
20 passwords=['123456','123123','7891234','password']
21 index = 0
22 for p in passwords:  #  for循环直接循环一个list，那么循环的时候就是每次取它的值
23     passwords[index] = 'abc_'+p
24     index+=1
25 print(passwords)
26 
27 
28 #输出结果：
29 ['abc_123456', 'abc_123123', 'abc_7891234', 'abc_password']

元组

元组是另一个数据类型(Python中的元组和Swift中的元组类似)
元组用”()”标识。内部元素用逗号隔开
元素不能二次赋值，相当于只读列表
元组也是一个不可变列表，元组不能修改

 1 # 元组
 2 tuple1 = (12, 34, 3.14, 5.3, 'titan')
 3 tuple2 = (10, 'jun')
 4 
 5 # 1.完整元组
 6 print(tuple1)
 7 
 8 # 2.元组一个元素
 9 print(tuple1[0])
10 
11 # 3.获取第2-3个元素
12 print(tuple1[2:3])
13 
14 # 4.获取第三个到最后的所有元素
15 print(tuple1[2:])
16 
17 # 5.获取最后一个元素
18 print(tuple1[-1])
19 
20 # 6.获取倒数第二个元素
21 print(tuple1[-2])
22 
23 # 7.获取最后三个元素
24 print(tuple1[-3:-1])
25 
26 # 8.合并元组
27 print(tuple1 + tuple2)
28 
29 # 9.重复操作两次
30 print(tuple2 * 2)
31

元组运算符

 1 # 计算元素个数
 2 print(len((1, 2, 3)))
 3 # 合并元组
 4 tuple1 = (1, 2) + (4, 5)
 5 print(tuple1)
 6 # 重复
 7 tuple2 = ('jun',) * 3
 8 print(tuple2)
 9 # 检测是否包含某元素
10 if (2 in tuple1):
11     print('2在该元组内')
12 else:
13     print('不在元组内')
14 # 遍历元组
15 for x in tuple1:
16     print(x)
17 
18 //输出:
19 3
20 (1, 2, 4, 5)
21 ('jun', 'jun', 'jun')
22 2在该元组内
23 1
24 2
25 4
26 5

元组内置函数

 1 tuple1 = (1, 2, 4, 5) 
 2 # 元组中元素最大值
 3 print(max(tuple1))
 4 # 元组中元素最小值
 5 print(min(tuple1))
 6 # 列表转换为元组
 7 print(tuple(['a', 'd', 'f']))
 8 
 9 //输出:
10 5
11 1
12 ('a', 'd', 'f')
13 
14  # 元组 只有一个字符串元素的时候，一定要加 引号。
15  tuple1.count(‘a’)# 统计某个元素在元组中出现的次数  
16 tuple1.index('a')   #从元组中找出某个值第一个匹配项的索引位置

字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过索引存取。
字典用”{ }”标识。字典由索引(key)和它对应的值value组成
这里的字典的key值, 不仅仅可以用字符串, 还可以用Number类型

K - V 形式，可循环优点：好取值，速度快

 1 hailong = {
 2     'name':'hailong',
 3     'sex':'男',
 4     'shengao':'185',
 5     'age':18,
 6     'email':'acb@qq.com',
 7     'addr':'火星',
 8     'id':2
 9 }
10 
11 # for i in hailong:
12 #     print(i)
13 #     if i =='name':
14 #         print(hailong[i])
15  # 无序输出
16 sex
17 age
18 shengao
19 name
20 hailong
21 id
22 email
23 addr
24 
25 
26 for  k,v in hailong.items():     # 字典转换成一个list
27     print(k,v)
28     
29 # 无序输出 
32 email acb@qq.com
33 id 2
34 name hailong
35 sex 男
36 shengao 185
37 addr 火星
38 age 18

 1 # 字典
 2 dict1 = {'name': 'jun', 'age': 18, 'score': 90.98}
 3 dict2 = {'name': 'titan'}
 4 
 5 # 完整字典
 6 print(dict2)
 7 
 8 # 1.修改或添加字典元素
 9 dict2['name'] = 'brother'
10 dict2['age'] = 20
11 dict2[3] = '完美'
12 dict2[0.9] = 0.9
13 print(dict2)
14 
15 # 2.根据键值获取value
16 print(dict1['score'])     #当查询的键不存在的时候，会报错

    print（dict1（get('score')））   #用get方法去查询字典，好处就是当查询的键不存在的时候，不会报错
17 
18 # 3.获取所有的键值
19 print(dict1.keys())
20 
21 # 4.获取所有的value值
22 print(dict1.values())
23 
24 # 5.删除字典元素
25 del dict1['name']
26 print(dict1)
27 
28 # 6.清空字典所有条目
29 dict1.clear()
30 print(dict1)
31 
32 # 7.删除字典/元素

1 #delete
2  dict1.pop('age')  # 删除指定key的值
3  print('删除age',dict1)4  dict1.popitem() #随机删除5  print(dict1)6 
7  del dict1['age'] #del 删除8  print(dict1）

33 dict3 = {2: 3}
34 del dict3
35 # 当该数组呗删除之后, 在调用会报错
36 # print(dict3)#合并字典 :字典合并，字典是没有顺序的，增加字段后位置也是随机放的d1 = {'a': 'A','b':'B'}d2 = {'c':'C'}d1.update(d2)print(d1)print(d2)# 输出{'a': 'A', 'c': 'C', 'b': 'B'}
{'c': 'C'}

 # 字典多层嵌套取值 1 all_stus = {
 2     'xiaojun':
 3     {
 4         'sex': '男',
 5         'shengao': '185',
 6         'age': 18,
 7         'email': 'acb@qq.com',
 8         'addr': '火星',
 9         'id': 1,
10         'cars':['牧马人','911','野马','劳斯莱斯']
11 
12     },
13     'hailong':{
14         'sex': '男',
15         'shengao': '185',
16         'age': 18,
17         'email': 'acb@qq.com',
18         'addr': '火星',
19         'id': 2
20     },
21     'yangfan':{
22         'sex': '男',
23         'shengao': '185',
24         'age': 18,
25         'email': 'acb@qq.com',
26         'addr': '火星',
27         'id': 3,
28         'bags':{
29             'qianbao':['lv','ysl'],
30             'beibao':['coach','abc']
31         }
32     }
33 }
34  all_stus['xiaojun']['cars'].append('五菱宏光') # 添加一个
35  print(all_stus['小军'])  #输出

1 {'addr': '火星', 'shengao': '185', 'sex': '男', 'age': 18, 'id': 1, 'cars': ['牧马人', '911', '野马', '劳斯莱斯', '五菱宏光'], 'email': 'acb@qq.com'}

36 print(len(all_stus['xiaojun']['cars']))# 输出    5
37 all_stus['yangfan']['sex'] = '女'
38  print(all_stus['yangfan']) # 输出

1 {'sex': '女', 'email': 'acb@qq.com', 'shengao': '185', 'id': 3, 'addr': '火星', 'bags': {'qianbao': ['lv', 'ysl'], 'beibao': ['coach', 'abc']}, 'age': 18}

39 all_stus['yangfan']['bags']['qianbao'].remove('lv') # 移除lv

print(all_stus['yangfan'])

#输出

1 {'sex': '男', 'email': 'acb@qq.com', 'addr': '火星', 'bags': {'beibao': ['coach', 'abc'], 'qianbao': ['ysl']}, 'age': 18, 'id': 3, 'shengao': '185'}

内置函数

 1 dic1 = {'name': 'titan', 'age':20}
 2 # 计算字典元素个数，即键的总数
 3 print(len(dic1))
 4 # 字典(Dictionary) str() 函数将值转化为适于人阅读的形式，以可打印的字符串表示
 5 print(str(dic1))
 6 # 返回输入的变量类型，如果变量是字典就返回字典类型
 7 print(type(dic1))
 8 
 9 //输出:
10 2
11 {'name': 'titan', 'age': 20}
12 <class 'dict'>

内置方法

copy（）、fromkeys()方法、get() 和 setdefault()方法、update()方法、pop() 和 popitem() 方法、其他方法

copy()方法

copy()函数返回一个字典的浅复制
直接赋值和 copy 的区别

 1 dict1 =  {'user':'runoob','num':[1,2,3]}
 2  
 3 dict2 = dict1          # 浅拷贝: 引用对象
 4 dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
 5  
 6 # 修改 data 数据
 7 dict1['user']='root'
 8 dict1['num'].remove(1)
 9  
10 # 输出
11 print(dict1)
12 print(dict2)
13 print(dict3)
14 
15 
16 # 输出结果
17 {'num': [2, 3], 'user': 'root'}
18 {'num': [2, 3], 'user': 'root'}
19 {'num': [2, 3], 'user': 'runoob'}
20 
21 实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，   dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改

fromkeys()方法

fromkeys() 函数用于创建一个新字典，
参数一: 以序列seq中元素做字典的键
参数二: value为字典所有键对应的初始值(可选参数)

 1 dict.fromkeys(seq[, value])
 2 
 3 # 使用
 4 dic2 = dict.fromkeys(['name', 'titan'])
 5 print(dic2)
 6 dic3 = dict.fromkeys(['name', 'titan'], 20)
 7 print(dic3)
 8 
 9 # 输出:
10 {'name': None, 'titan': None}
11 {'name': 20, 'titan': 20}

get() 和 setdefault()方法

get() 函数返回指定键的值，如果值不在字典中返回默认值
setdefault()和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值(同事也会把键值对添加到字典中)
参数一: 字典中要查找的键。
参数二: 如果指定键的值不存在时，返回该默认值值(可选参数) ,即找不到键的值也不会报错

 1 dict.get(key, default=None)
 2 
 3 # 使用
 4 dic5 = {'name': 'titan', 'age':20}
 5 print(dic5.get('name'))
 6 print(dic5.get('Sex', 'man'))
 7 print(dic5.setdefault('name'))
 8 print(dic5.setdefault('Sex', 'man'))
 9 print(dic5)   print(dics2.setdefault('name','Tan')) #如果这个key已经存在，那么就不修改它的值了
10 
11 # 输出结果:
12 titan
13 man
14 titan
15 man
16 {'name': 'titan', 'age': 20, 'Sex': 'man'}

其他方法

 1 dic2 = {'name': 'titan', 'age':20}
 2 # 判断键是否存在于字典中, 在True, 不在False
 3 print(dic2.__contains__('name'))
 4 
 5 # 以列表返回可遍历的(键, 值) 
 6 print(dic2.items())
 7 
 8 # 删除字典内所有元素
 9 dic2.clear()
10 print(dic2)
11 
12 
13 # 输出结果:
14 True
15 dict_items([('name', 'titan'), ('age', 20)])
16 {}

切片：就是list取值的一种方式

 1 # 切片 ： 就是list取值的一种方式
 2  3 l = ['a','b','c','d','e','j','k','l','m','n','o']
 4     # 0    1  2   3   4   5   6    7   8   9   10
 5 print(l[2:8])  # 顾头不顾尾
 6 print(l[:5])  # 如果最前面没写的话，代表从0开始取的
 7 print(l[4:])  # 如果冒号后面的没写的话，代表去到最后
 8 print(l[:])  # 如果冒号后面的没写的话，代表去到最后
 9 print(l[::3])  # 步长，也就是代表隔几个取一次，
10 nums = list(range(1,11))

 # 1 2 3 4 5 6 7 8 9 10

11 print(nums[1::2]) # 取偶数， 12 print(nums[::2]) # 取奇数 13 14 print(nums) 15 print(nums[::-1]) # 取奇数 16 # 如果最后面的步长是正数的话， 那就从左到右开始取值 17 # 如果后面的步长是负数的话，那么就从右往左开始取值 18 19 #输出结果 ： 20 ['c', 'd', 'e', 'j', 'k', 'l'] 21 ['a', 'b', 'c', 'd', 'e'] 22 ['e', 'j', 'k', 'l', 'm', 'n', 'o'] 23 ['a', 'b', 'c', 'd', 'e', 'j', 'k', 'l', 'm', 'n', 'o'] 24 ['a', 'd', 'k', 'n'] 25 [2, 4, 6, 8, 10] 26 [1, 3, 5, 7, 9] 27 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 28 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

切片，同样也使用于字符串

 1 # 切片 同样适用于字符串。
 2 words='中秋节要放假'
 3 print(words[::-1])
 4 for index,w in enumerate(words):
 5     print('每次打印的',index,w)
 6 
 7 
 8 # 输出结果 ：
 9 假放要节秋中
10 每次打印的 0 中
11 每次打印的 1 秋
12 每次打印的 2 节
13 每次打印的 3 要
14 每次打印的 4 放
15 每次打印的 5 假

回文算法 ： 反过来 倒过去都一样

 1 # 回文算法，反过来倒去过都一样
 2 # 如：
 3 #s ='上海自来水来自海上'
 4 # 1232321
 5 # 1111
 6 # 5678 8765 
 7 #
 8 for i in range(10):
 9     s = input('请输入一个字符串：')
10     if len(s)<2:
11         print('字符串长度必须大于1')    
12     elif s==s[::-1]:
13         print('是回文')
14     else:
15         print('不是回文')
16 
17 
18 #  输出结果 ：
19 请输入一个字符串：1232321
20 是回文
21 请输入一个字符串：56788765
22 是回文
23 请输入一个字符串：56788765
24 是回文
25 请输入一个字符串：1
26 字符串长度必须大于1
27 请输入一个字符串：11
28 是回文
29 请输入一个字符串：

字符串的常用方法    s='anc'    s.upper()    s.lower()    s.capitalize()    s.split(',')    s.strip('abc')    s.lstrip()    s.rstrip()    s.replace('old','new')    s.endswith('xxx.mp3')    s.startswith('186')    ','.join('sdfsdfds')    s.isdigits()    s.isalnum()    s.zfill(5)

来源：https://www.cnblogs.com/tanzitanzi/p/9553731.html

标签

Python基础教程笔记一：数据类型

孤者浪人 — Mon, 06 Apr 2020 21:33:07 +0000

Python基础教程笔记一：数据类型孤者浪人 2020-04-07 05:33:07

五种数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）

Python支持四种不同的数字类型：

int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）

Numbers(数字)

var1 = 1
var2 = 10

不用时，可以通过del删除

del var1
del var2

String(字符串)

字符串或串(String)是由数字、字母、下划线组成的一串字符。

一般记为 :

s="a1a2···an"(n>=0)

python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如:

s = 'ilovepython'

s[1:5]的结果是love

str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

list(列表)

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

以上输出为：

['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

tuple(元组)

元组是另一个数据类型，类似于List（列表）。

元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第三个的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

以上输出为：

('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

dictionary(字典)

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

以上输出为：

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

Python允许你同时为多个变量赋值。例如：

a = b = c = d = 1008611

或者多个变量多个赋值

a,b,c,d = 'tom' ,'jerry',18,20

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

来源：https://www.cnblogs.com/zhan1995/p/8890112.html

标签

Python基础语法（二）

妖精的绣舞 — Mon, 06 Apr 2020 21:03:05 +0000

Python基础语法（二）妖精的绣舞 2020-04-07 05:03:05

1、Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的；

2、python中单行注释采用 # 开头；

3、python 中多行注释使用三个单引号(''')或三个双引号(""")；

4、空行也是程序代码的一部分；

5、Python可以在同一行中使用多条语句，语句之间使用分号(;)分割；\n 实现换行；

6、Python可以在同一行中使用多条语句，语句之间使用分号(;)分割；

7、print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号；

8、像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束；（缩进相同的一组语句构成一个代码块，我们称之代码组）

9、Python 中的变量赋值不需要类型声明；每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

10、多个变量赋值；

a = b = c = 1；
a, b, c = 1, 2, "bob"

11、Python有五个标准的数据类型：
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
----------------------------------------------------------------------------------------
Python数字

var1 = 1
var2 = 2
var3 = 3

del var1[,var2[,var3[....,varN]]]] (del语句删除一些对象的引用)

del var ****** del var_a, var_b (del语句删除单个或多个对象的引用)

Python支持四种不同的数字类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
-------------------------------------------------------------------------------------
Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

一般记为 :

s="a1a2···an"(n>=0)

从左到右索引默认0开始的，最大范围是字符串长度少1;

从右到左索引默认-1开始的，最大范围是字符串开头;

其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾;
-------------------------------------------------------------------------------------
Python列表

List（列表）是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的截取也可以用到变量 [头下标:尾下标] ，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

组合的列表(直接用+号，效果类似js的数组合并)
-------------------------------------------------------------------------------------
Python元组

元组是另一个数据类型，类似于List（列表）。

元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

组合的元组(直接用+号，效果类似js的数组合并)

元组和列表的区别是：元组是不允许更新（重新赋值）的，而列表是允许更新；
-------------------------------------------------------------------------------------
Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

字典类似js里面的对象的操作，字典.keys() # 输出所有键/字典.values()# 输出所有值(类似对象的遍历方法)

数据类型的转换，只需要将数据类型作为函数名即可！

来源：https://www.cnblogs.com/lhl66/p/9567059.html

标签

如何通过索引从列表中删除元素？

蓝咒 — Sun, 05 Apr 2020 18:01:00 +0000

如何通过索引从列表中删除元素？蓝咒 2020-04-06 02:01:00

问题：

How do I remove an element from a list by index in Python? 如何在Python中按索引从列表中删除元素？

I found the list.remove method, but say I want to remove the last element, how do I do this? 我找到了list.remove方法，但是说我想删除最后一个元素，该怎么做？ It seems like the default remove searches the list, but I don't want any search to be performed. 似乎默认的remove搜索列表，但是我不希望执行任何搜索。

解决方案：

参考一： https://stackoom.com/question/2dDv/如何通过索引从列表中删除元素
参考二： https://oldbug.net/q/2dDv/How-to-remove-an-element-from-a-list-by-index

来源：oschina

链接：https://my.oschina.net/stackoom/blog/3220067

标签

python列表

Deepin Eclipse 创建 PyDev 工程

…衆ロ難τιáo~ — Sun, 05 Apr 2020 16:26:07 +0000

Deepin Eclipse 创建 PyDev 工程 …衆ロ難τιáo~ 2020-04-06 00:26:07

第一次要选择 Python Interpreter，这个比较重要，见下面截图：

点 Manual config 按钮，出现下面窗口：

点击 Choose from list 按钮，这时候可能出现两种情况：

第一种，列表中包括 venv 中的 Python，这是我所期望的如下图所示：

venv 中有三个 Python 的执行程序，实际上是同一个，如下图所示：

还有一种情况是，列表中没有 venv 路径下的，如下图所示：

这次只列出了系统中的 Python 可执行程序，没有列出 venv 下面的。

经过调查，这是因为激活 venv 的语句没有添加到 .profile 中引起的，添加后注销当前用户，重新登录，即可解决这个问题。

继续往下走，进入这里：

默认全选，点 OK 按钮，看到下面：

点 Apply and Close 按钮。至此，选择 Python Interpretor 的操作就做完了。

其它操作例行完成即可。

来源：https://www.cnblogs.com/liuwei-a/p/10159490.html

标签

python 反转列表的3种方式

隐身守侯 — Sun, 05 Apr 2020 14:55:42 +0000

python 反转列表的3种方式隐身守侯 2020-04-05 22:55:42

转载自：https://blog.csdn.net/bookaswine/article/details/42468735

方式一:使用reversed()函数

a=[1,2,3,4,5,6,7,8,9]
b=list(reversed(a))
print b

注意：reversed()函数返回的是一个迭代器，而不是一个List，需要再使用List函数转换一下。

方式二:使用sorted()

a=[1,2,3,4,5,6,7,8,9]
c=sorted(a,cmp=None, key=None, reverse=True)
print c

注意：其中reverse=True是按降序排列，reverse=False是按照升序排列

方式三: 使用分片

a=[1,2,3,4,5,6,7,8,9]
d=a[::-1]
print d

注意：其中[::-1]代表从后向前取值，每次步进值为1

来源：https://www.cnblogs.com/star12111/p/8881939.html

标签

python函数

python列表

python

计算与软件工程作业四

感情迁移 — Sun, 05 Apr 2020 10:03:50 +0000

计算与软件工程作业四感情迁移 2020-04-05 18:03:50

问题	回答
作业要求	第四周作业
课程目标	代码复审，结对编程
在哪方面帮我实现课程目标	能够帮助我更好的规范代码风格；通过合作学习提高自己的团队意识与操作能力
参考文献	(https://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html) (https://www.cnblogs.com/xinz/archive/2011/10/22/2220872.html)
gitee	(https://gitee.com/yzzzw/Array)

作业1

每个人针对之前两次作业所写的代码，针对要求，并按照代码规范（风格规范、设计规范）要求评判其他学生的程序，同时进行代码复审（按照代码复审核表）
评价内容直接放在你被评价的作业后面评论中
同时另建立一个博客，将你作的评论的截图或者链接，放在博客中，并在你的博客中谈谈自己的总体看法
作业一链接：(https://www.cnblogs.com/yzzzw/p/12636544.html)

作业2

1、实现一个简单而完整的软件工具（中文文本文件人物统计程序）：针对小说《红楼梦》要求能分析得出各个人物在每一个章回中各自出现的次数，将这些统计结果能写入到一个csv格式的文件。
2、进行单元测试、回归测试、效能测试，在实现上述程序的过程中使用相关的工具。
3、进行个人软件过程（PSP）的实践，逐步记录自己在每个软件工程环节花费的时间。
4、使用源代码管理系统 (GitHub, Gitee， Coding.net, 等)；
5、针对上述形成的软件程序，对于新的文本小说《水浒传》分析各个章节人物出现次数，来考察代码。
将上述程序开发结对编程过程记录到新的博客中，尤其是需要通过各种形式展现结对编程过程，并将程序获得的《红楼梦》与《水浒传》各个章节人物出现次数与全本人物出现总次数，通过柱状图、饼图、表格等形式展现。
《红楼梦》与《水浒传》的文本小说将会发到群里。
注意，要求能够分章节自动获得人物出现次数
队友链接：(https://www.cnblogs.com/tang-yuan-yuan/p/12637150.html)

python准备工作

先下载python，并安装好所需要的模块——jieba和matplotlib

python运行结果（红楼梦）

在python中按题目要求先将出现的高频词汇去除，再统计出红楼梦和水浒传人物出现的次数，并导入到csv文件中。

PSP

PSP各个阶段	预估时间	实际记录
计划：明确需求和其他因素，估计以下的各个任务需要多少时间	一小时	一天
开发
需求分析	一小时	三小时
生成设计文档	一小时	一小时
具体代码	五小时	五小时
测试	一小时	两小时
事后总结	两小时	两小时
总共花费的时间	十一小时	两天

代码

#统计红楼梦人物出现次数代码
print("红楼梦人物出场次数：")   
import jieba
import time
start=time.perf_counter()
txt=open("红楼梦.txt","r",encoding="utf-8").read()
excludes={"什么","一个","如今","人马","你们","我们","说道","知道","起来","今日","这里",        
          "什么","他们","两个","只见","如何","那里","姑娘","众人","这里","出来","奶奶","怎么","没有",
          "太太","这个","听见","这样","进来","三个","不得","如此","次日","只是","不知","不是","却是","不曾",
          "告诉","东西","就是","咱们","不敢","一面","自己","只得","正是","回来","老爷","大家","这些",
          "丫头","出去"}
words=jieba.lcut(txt)
counts={}
for word in words:
    if len(word)==1:       
        continue    
    elif word=="老太太":        
        rword="贾母"       
    else:        
        rword=word        
        counts[word]=counts.get(word,0)+1
for word in excludes:    
    del counts[word]
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(10):    
    word,count=items[i]    
    print("{0:<10}{1:>5}次".format(word,count))
dur=time.perf_counter()-startprint("运行时间为{:.2f}s".format(dur))
print("-----------------------------")

#红楼梦人物出现次数导入csv
#导入csv安装包
import csv

#1、创建文件对象
with open('HLMcsv.csv','w',newline="") as csvfile:

#2、基于文件对象构建csv写入对象
    writer=csv.writer(csvfile)

#3、构建列表头
    writer.writerow(["人物","出现次数"])

#4、写入csv文件内容
    writer.writerow(["宝玉","3445"])
    writer.writerow(["贾母","1144"])
    writer.writerow(["凤姐","1038"])
    writer.writerow(["王夫人","969"])
    writer.writerow(["贾琏","671"])
    writer.writerow(["平儿","585"])
    writer.writerow(["袭人","551"])
    writer.writerow(["黛玉","540"])
    writer.writerow(["宝钗","521"])
    writer.writerow(["薛姨妈","455"])

#红楼梦树状图与饼状图
import jieba
from collections import Counter
import matplotlib.pyplot as plt
import numpy as np


class HlmNameCount():
    # 此函数用于绘制条形图
    def showNameBar(self,name_list_sort,name_list_count):
        # x代表条形数量
        x = np.arange(len(name_list_sort))
        # 处理中文乱码
        plt.rcParams['font.sans-serif'] = ['SimHei']
        # 绘制条形图，bars相当于句柄
        bars = plt.bar(x,name_list_count)
        # 给各条形打上标签
        plt.xticks(x,name_list_sort)
        # 显示各条形具体数量
        i = 0
        for bar in bars:
            plt.text((bar.get_x() + bar.get_width() / 2), bar.get_height(), '%d' % name_list_count[i], ha='center', va='bottom')
            i += 1
        # 显示图形
        plt.show()

    # 此函数用于绘制饼状图
    def showNamePie(self, name_list_sort, name_list_fracs):
        # 处理中文乱码
        plt.rcParams['font.sans-serif'] = ['SimHei']
        # 绘制饼状图
        plt.pie(name_list_fracs, labels=name_list_sort, autopct='%1.2f%%', shadow=True)
        # 显示图形
        plt.show()

    def getNameTimesSort(self,name_list,txt_path):
        # 将所有人名临时添加到jieba所用字典，以使jieba能识别所有人名
        for k in name_list:
            jieba.add_word(k)
        # 打开并读取txt文件
        file_obj = open(txt_path, 'rb').read()
        # jieba分词
        jieba_cut = jieba.cut(file_obj)
        # Counter重新组装以方便读取
        book_counter = Counter(jieba_cut)
        # 人名列表，因为要处理凤姐所以不直接用name_list
        name_dict ={}
        # 人名出现的总次数，用于后边计算百分比
        name_total_count = 0
        for k in name_list:
            if k == '熙凤':
                # 将熙凤出现的次数合并到凤姐
                name_dict['凤姐'] += book_counter[k]
            else:
                name_dict[k] = book_counter[k]
            name_total_count += book_counter[k]
        # Counter重新组装以使用most_common排序
        name_counter = Counter(name_dict)
        # 按出现次数排序后的人名列表
        name_list_sort = []
        # 按出现次数排序后的人名百分比列表
        name_list_fracs = []
        # 按出现次数排序后的人名次数列表
        name_list_count = []
        for k,v in name_counter.most_common():
            name_list_sort.append(k)
            name_list_fracs.append(round(v/name_total_count,2)*100)
            name_list_count.append(v)
            # print(k+':'+str(v))
        # 绘制条形图
        self.showNameBar(name_list_sort, name_list_count)
        # 绘制饼状图
        self.showNamePie(name_list_sort,name_list_fracs)
        

if __name__ == '__main__':
    # 参与统计的人名列表，可修改成自己想要的列表
    name_list = ['宝玉', '贾母', '凤姐', '王夫人', '贾琏', '平儿', '袭人', '黛玉', '宝钗', '薛姨妈']
    # 红楼梦txt文件所在路径，修改成自己文件所在路径
    txt_path = 'F:/Python/红楼梦.txt'
    hnc = HlmNameCount()
    hnc.getNameTimesSort(name_list,txt_path)

#水浒传人物出现次数
print("水浒传人物出场次数：")   
import jieba
import time
start=time.perf_counter()
txt=open("水浒传.txt","r",encoding="utf-8").read()
excludes={"二人","一个","来到","人马","你们","我们","好汉","军马","小人","今日","这个","先锋","宋江道",        
          "知府","什么","他们","银子","梁山","两个","只见","如何","那里","说道","众人","这里","兄弟","出来",
          "妇人","便是","起来","问道","因此","三个","不得","如此","次日","只是","不知","不是","却是","呼延","不曾",
          "梁山泊","一面","且说","看时","不敢","如今","原来","将军","山寨","只得","正是","喝道","一齐","当下",
          "兄长"}
words=jieba.lcut(txt)
counts={}
for word in words:
    if len(word)==1:       
        continue    
    elif word=="哥哥":        
        rword="宋江"    
    elif word=="头领":        
        rword="林冲"    
    else:        
        rword=word        
        counts[word]=counts.get(word,0)+1
for word in excludes:    
    del counts[word]
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(10):    
    word,count=items[i]    
    print("{0:<10}{1:>5}次".format(word,count))
dur=time.perf_counter()-startprint("运行时间为{:.2f}s".format(dur))
print("-----------------------------")

#水浒传任务出现次数导入csv
#导入csv安装包
import csv

#1、创建文件对象
with open('SHZcsv.csv','w',newline="") as csvfile:

#2、基于文件对象构建csv写入对象
    writer=csv.writer(csvfile)

#3、构建列表头
    writer.writerow(["人物","出现次数"])

#4、写入csv文件内容
    writer.writerow(["宋江","2447"])
    writer.writerow(["李逵","1093"])
    writer.writerow(["武松","1027"])
    writer.writerow(["林冲","693"])
    writer.writerow(["吴用","626"])
    writer.writerow(["卢俊义","547"])
    writer.writerow(["鲁智深","325"])
    writer.writerow(["柴进","305"])
    writer.writerow(["戴宗","301"])
    writer.writerow(["公孙胜","272"])

#水浒传树状图和饼状图
import jieba
from collections import Counter
import matplotlib.pyplot as plt
import numpy as np


class HlmNameCount():
    # 此函数用于绘制条形图
    def showNameBar(self,name_list_sort,name_list_count):
        # x代表条形数量
        x = np.arange(len(name_list_sort))
        # 处理中文乱码
        plt.rcParams['font.sans-serif'] = ['SimHei']
        # 绘制条形图，bars相当于句柄
        bars = plt.bar(x,name_list_count)
        # 给各条形打上标签
        plt.xticks(x,name_list_sort)
        # 显示各条形具体数量
        i = 0
        for bar in bars:
            plt.text((bar.get_x() + bar.get_width() / 2), bar.get_height(), '%d' % name_list_count[i], ha='center', va='bottom')
            i += 1
        # 显示图形
        plt.show()

    # 此函数用于绘制饼状图
    def showNamePie(self, name_list_sort, name_list_fracs):
        # 处理中文乱码
        plt.rcParams['font.sans-serif'] = ['SimHei']
        # 绘制饼状图
        plt.pie(name_list_fracs, labels=name_list_sort, autopct='%1.2f%%', shadow=True)
        # 显示图形
        plt.show()

    def getNameTimesSort(self,name_list,txt_path):
        # 将所有人名临时添加到jieba所用字典，以使jieba能识别所有人名
        for k in name_list:
            jieba.add_word(k)
        # 打开并读取txt文件
        file_obj = open(txt_path, 'rb').read()
        # jieba分词
        jieba_cut = jieba.cut(file_obj)
        # Counter重新组装以方便读取
        book_counter = Counter(jieba_cut)
        # 人名列表，因为要处理宋江所以不直接用name_list
        name_dict ={}
        # 人名出现的总次数，用于后边计算百分比
        name_total_count = 0
        for k in name_list:
            if k == '哥哥':
                name_dict['宋江'] += book_counter[k]
            else:
                name_dict[k] = book_counter[k]
            name_total_count += book_counter[k]
        # Counter重新组装以使用most_common排序
        name_counter = Counter(name_dict)
        # 按出现次数排序后的人名列表
        name_list_sort = []
        # 按出现次数排序后的人名百分比列表
        name_list_fracs = []
        # 按出现次数排序后的人名次数列表
        name_list_count = []
        for k,v in name_counter.most_common():
            name_list_sort.append(k)
            name_list_fracs.append(round(v/name_total_count,2)*100)
            name_list_count.append(v)
            # print(k+':'+str(v))
        # 绘制条形图
        self.showNameBar(name_list_sort, name_list_count)
        # 绘制饼状图
        self.showNamePie(name_list_sort,name_list_fracs)
        

if __name__ == '__main__':
    # 参与统计的人名列表，可修改成自己想要的列表
    name_list = ['宋江', '李逵', '武松', '林冲', '吴用', '卢俊义', '鲁智深', '柴进', '戴宗', '公孙胜']
    # 水浒传txt文件所在路径，修改成自己文件所在路径
    txt_path = 'F:/Python/水浒传.txt'
    hnc = HlmNameCount()
    hnc.getNameTimesSort(name_list,txt_path)

运行结果（水浒传）

上传到码云

码云链接：(https://gitee.com/yzzzw/Array)

来源：https://www.cnblogs.com/yzzzw/p/12626487.html

标签

第五章列表、元祖和字符串

僤鯓⒐⒋嵵緔 — Sun, 05 Apr 2020 09:54:28 +0000

第五章列表、元祖和字符串僤鯓⒐⒋嵵緔 2020-04-05 17:54:28

5.1 列表

　　定义：python的变量没有数据类型，它的列表可以同时存放不同类型的变量。

　　创建：用中括号将数据包裹起来（数据之间用英文逗号隔开），贴上一个变量名，方便后面可以调用。

 1 number = [1,2,3,4,5,6]
 2 for each in number:
 3         print(each)
 4 
 5 1
 6 2
 7 3
 8 4
 9 5
10 6

　　向列表中添加元素：

　　　　append() #append()方法是属于列表对象的方法，是将元素添加到列表的末尾，但是只能添加一个参数。

　　　　extend() #extend()事实上是使用一个列表来扩充另外一个列表，所以他的参数是另一个列表，添加在列表的末尾。

　　　　insert() #insert()方法有两个参数：第一个参数是指定待插入的位置（索引值），第二个参数是待插入的元素值。第一个参数的值还支持负数，表示与列表，末尾的相对距离。

number = [1,2,3,4,5,6]
number.append(7)
number
[1, 2, 3, 4, 5, 6, 7]

number.extend([8,9])
number
[1, 2, 3, 4, 5, 6, 7, 8, 9]

number.insert(0,0)
number
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
number.insert(-1,8.5)
number
[0, 1, 2, 3, 4, 5, 6, 7, 8, 8.5, 9]

　　从列表中获取元素：

　　　1跟数组一样，我们可以荣国元素的索引值（index)从列表获取单个元素，注意列表索引值是从0开始的。

　　　2访问列表中最后一个元素的方法：用len()函数获取列表的长度，再减1就是这个列表最后一个元素的索引值；当索引值为负数时，从列表末尾反向索引。

　　　3将列表的元素位置互换以及随机抽取

# 通过索引值直接获取列表中的某个元素
eggs = ['鸡蛋','鸭蛋','鹅蛋','铁蛋']
eggs[0]
'鸡蛋'
eggs[2]
'鹅蛋'

eggs[len(eggs)-1]
'铁蛋'
eggs[-1]
'铁蛋'

#将铁蛋和鸭蛋互换位置,temp为临时变量，避免相互覆盖。
temp = eggs[1]
eggs[1] = eggs[-1]
eggs[-1] = temp
eggs
['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']

eggs[1],eggs[-1] = eggs[-1],eggs[1]
eggs
['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']

#抽奖,random的choice()方法可以从一个非空序列中随机获取一个元素。
import random
prizes = ['鸡蛋','鸭蛋','鹅蛋','铁蛋']
random.choice(prizes)
'鸭蛋'
>>> random.choice(prizes)
'鹅蛋'

来源：https://www.cnblogs.com/wyzq9294/p/12635610.html

标签

python列表

索引

python列表

python数据类型（二）

python基础---数据类型（二）

回顾和补充

今日内容

1.列表

公用功能

独有功能

2.元组

1.元组的书写规范

公共功能：

独有功能（真tm惨，没有自己功能

Python-字符串及列表操作-Day2

1.数据类型

1.1 变量引出数据类型

1.2 五大基本数据类型：

1.2.1 数字

1.2.2 整型

1.2.3 布尔

1.2.4 浮点float

1.2.5 复数

1.3 字符串

1.3.1 字符串模块方法1：

1.3.2 字符串模块方法2：

1.3.3 字符串常用的操作

2. 运算符

2.1 算数运算

2.2 比较运算

2.3 赋值运算

2.4 位运算

2.5 逻辑运算

and注解：

or注解：

and-or结合使用：

2.6 成员运算

2.7 身份运算

3. for循环

写程序最忌讳的就是重复代码！！！

3.1 猜年龄程序：

3.2 for循环else语法测试：

3.3 for循环-嵌套循环：

3.4 while 循环

4. 列表

4.1 列表功能

定义一个列表：names = []

或者name = list(1,2,4)

names = []最终调用的就是list这个类

4.1.1 增 append

names.append()

4.1.2 删 del pop() remove()

删除的三种方式：

names.remove()

names.pop()

del names[index]

4.1.3 改

4.1.4 查

4.1.5 计数 count()

4.1.6 清空 clear()

4.1.7 扩展合并 extend()

4.1.8 排序 sort()

name.sort() #排序

4.1.9 反转 reverse()

4.1.10 copy()

copy语法重新制定内存与原内容内存id存储位置不同

4.1.11 列表的长度len()

4.3 循环一个列表

4.4 列表的判断

4.5 数据类型转换内置函数汇总

5 Python整理-小记

5.1 执行脚本传入参数

5.2 sys os 模块小记

5.2.1 sys 模块

5.2.2 os模块

5.2.3 完全结合一下

Python学习笔记二——数据类型及数据操作

概要 ：

基本语法 -

标准数据类型

字符串

List（列表）

5.2.3 完全结合一下　　

概要：

第五章列表、元祖和字符串