python笔记(3)--数据类型（列表、元组）

数据类型（二）

今日内容：

  • 列表
  • 元组

内容回顾和补充：

  1. 计算机基础：

    • 硬件：CPU/内存/硬盘/主板/网卡

    • 操作系统：

      • Linux（免费/开源）
        • centos
        • ubuntu
        • redhat
      • windows
      • mac

    • 解释器/编译器

      • 补充：编译型语言和解释型语言？

        # 编译型：代码写完后，编译器将其变成另外一个文件，然后交给计算机执行。
# 解释型：写完代码交给解释器，解释器会从上到下一行行执行代码：边解释边执行。

    • 软件（应用程序）

  2. 环境安装：

    • python解释器
      • py2
      • py3
    • 开发工具：pycharm（推荐）/ 文本编辑器

  3. python语法

    1. 解释器路径：hello.py

      #!/usr/bin/env python
print("你好")

      Linux系统应用：

      • 赋予文件可执行文件
      • ./hello.py

    2. 编码：

      #!/usr/bin/env python
# -*- coding:utf-8 -*-
python("你好")
      1. 编码种类：
        • ASCII
        • unicode
        • utf-8 / utf-16
        • gbk / gbk2312
      2. 中文表示：
        • utf-8 : 3字节
        • gbk：2字节
      3. python默认解释器编码：
        • py3：utf-8
        • py2：ascii

    3. 输入输出：

      • py2：
        • 输入：raw_input
        • 输出：print ""
      • py3：
        • 输入：input
        • 输出：print（）

    4. 数据类型：

      1. int
        • py2中有：int / long；py3中只有int
        • 强制转换：int（"76"）
        • 除法：py2（多加一行代码可以精确到小数）和py3（正常）
      2. bool
        • True / False
        • 特殊为False的其他类型：0 和 ""
      3. str：
        • 独有功能：
          • upper / lower
          • replace
          • strip / rstrip / lstrip
          • isdigit
          • split / rsplit
          • startswitch / endswitch
          • format
          • encode
          • join
        • 公共功能：
          • 索引：获取一个字符
          • 切片：获取一段字符串（子序列）。
          • 步长：根据步长取值
          • 长度：len()
          • for循环

    5. 变量（见名知意）

    6. 注释

    7. 条件语句

    8. 循环语句：while + for + break + continue

    9. 运算符

    10. 字符串格式化

      • %s
      • %d
      • %%

内容详细：

1.列表

详细：以后想要表示多个“事物”，可以使用列表。

  • 数字、字符串、布尔类型无法修改删除期中的元素
  • 列表可以对其中的元素进行增删改查
users = ["yanan","yazhou",77]

公共功能：

  • len
  • 索引
  • 切片
  • 步长
  • for循环

独有功能：

  1. append 追加：在列表的最后追加一个元素
    • 列表.append("追加元素")
#在列表中追加：
user = ["小黑","船长","末日"]
user.append("李亚楠")
print(user)    #结果为['小黑', '船长', '末日', '李亚楠']
#往列表中追加元素：
users=[]			#空列表
while True:
    name = input("请输入名字：")
    users.append(name)
    print(users)
#录入三次用户名和密码，存放在列表中：    
users=[]
for i in range(0,3):
    name = input("用户名和密码：")
    users.append(name)
print(users)

  1. extend 将一个(字符串 / 元组 / 列表)循环其中的每个元素，并追加到一个列表中

    li = ["小黑","船长","武器","螃蟹"]
L2 = ["瞎子","诺克","德玛"]
li.extend(L2)	#结果为["小黑","船长","武器","螃蟹","瞎子","诺克","德玛"]

li = ["小黑","船长","武器","螃蟹"]
L2 = ("瞎子","诺克","德玛")
li.extend(L2)	#结果为["小黑","船长","武器","螃蟹","瞎子","诺克","德玛"]

li = ["小黑","船长","武器","螃蟹"]
name = "烬劫"
li.extend(name)
print(li)		#结果为['小黑', '船长', '武器', '螃蟹', '烬', '劫']

  2. insert插入：在元素下标位置前插入

    • 列表.insert(下标位，"插入元素")
    user = ["小黑","船长","末日"]
user.insert(1,"李亚楠")
print(user)
#结果为['小黑', '李亚楠', '船长', '末日']

  3. remove / pop / clear 删除：在列表中删除或清空元素。注意：如果有同样的元素，则删除第一个

    • 列表.remove("删除的元素")
    • 列表.pop(需要删除的下标号) ：不仅仅是删除，还可以将删除的值赋值在变量上
      • del 列表[下标] ：只是删除
    • 列表.clear() #清空列表
    #在列表中删除元素
user = ["小黑","船长","末日","小黑"]
user.remove("小黑")
print(user)    #结果为['船长', '末日']
#注意，如果列表中有多个一样的删除元素，则删除第一个
user = ["小黑","船长","末日","小黑"]
user.remove("小黑")
print(user)    #结果为['船长', '末日','小黑']

#根据下标位置删除元素
user = ["小黑","船长","末日"]
user.pop(2)		
#del user[2]		
user.pop()		#如果pop参数为空则删除最后一个
print(user)		#结果为['小黑']

#根据下标位置删除元素并将其赋予新的变量
user = ["小黑","船长","末日"]
deleted = user.pop(2)
print(user)		#结果为列表：   ['小黑','船长']
print(deleted)	#结果为字符串：  末日   

#清除列表
user = ["小黑","船长","末日"]
user.clear()
print(user)

  4. 修改：

    • 列表[需要修改的下标] = "修改的内容"
    user = ["小黑","船长","末日"]
user[0] = "稻草人"
print(user)
#结果为['稻草人', '船长', '末日']

总结：

  • 增
    • append / insert|
  • 删
    • remove / pop / clear / del users[2]
  • 改
    • users[3] = "新值"
  • 查
    • 索引 / 切片

列表的嵌套：

users = ["小黑",456,"船长","女警官",["路飞","草帽",["火影","哪吒",856]],"eil","pop","iklo"]

users[2] 		#取出"船长"
users[4][0] 	#取出"路飞"
users[3][1]		#取出警
users[4][1][1]	#取出"帽"
users[4] = 666	#将["路飞","草帽",["火影","哪吒",856]]修改为666

2.元组 tuple

  1. 元组的书写

    user = [11,22,33,"小黑"] #列表可变

user = (11,22,33,"小黑") #元组不可变

  2. 公共功能：

    • 索引
    • 切片
    • 步长
    • for循环
    • len()

  3. 独有功能（无）

  4. 特殊：元组中的元素不可修改 / 删除

    v1 = (11,22,33)
v1[1] = 999  #错误，元组不可修改
v1 = 999	#正确，变量重新被赋值为999

#可以嵌套
v1 = (11,22,33,(44,55,66),77)

#列表嵌套元组
v2 = [11,22,33,"小黑",(11,22,33),88] #列表可以嵌套元组
v2[-2][0] = 666	#错误，列表内的元组不可修改
v2[-2] = 666	#正确，列表内的元组被重新赋值了

#元组嵌套列表
v3 = (11,22,33,[44,55,66])
v3[-1] = 666 	#错误，元组内列表整体元素属于元组，不可修改
v3[-1][1] = 666	#正确，元组内列表的元素进行修改，可以修改

总结：

  1. 解释型语言和编译型语言的区别以及列举你了解的语言

  2. 字符串的补充：

    • 独有
      • startswitch / endswitch
      • format
      • encode
      • join
    • 公共
      • 切片
      • 索引
      • len()
      • 步长 #面试题
      • for循环
      • range（0,10）#生成一个数字列表[0,1,2,3,4,5,6,7,8,9]
    • 特性
      • 不可变，所以字符串元素不能删除和修改

  3. git本地和远程要同步，以后只能操作本地然后提交

  4. 列表（可变）

    • 公共
      • 索引
      • 切片
      • 步长
      • 修改
      • 删除 (del)
      • for循环
      • len()
    • 独有
      • append
      • insert
      • pop
      • remove
      • clear
    • 列表嵌套

  5. 元组（不可变）

    • 公共

      • 索引
      • 切片
      • 步长
      • for
      • len()

    • 独有功能（无）

    • 元组的嵌套(容易出错的例子，记住)

      #元组嵌套列表
v3 = (11,22,33,[44,55,66])
v3[-1] = 666 	#错误，元组内列表整体元素属于元组，不可修改
v3[-1][1] = 666	#正确，元组内列表的元素进行修改，可以修改

作业：

  1. 简述解释型语言和编译型语言的区别

  2. 列举你了解的python的数据类型

    • 字符串 str
    • 整形 int
    • 布尔 bool
    • 列表 list
    • 元组 tuple

  3. 请将一个列表追加到另外一个列表中

    #li = ["小黑","船长","武器","螃蟹"]   追加到    L2 = ["瞎子","诺克","德玛"]
#方法一：使用for循环打印列表li，并追加到列表L2中
li = ["小黑","船长","武器","螃蟹"]
L2 = ["瞎子","诺克","德玛"]
for item in li:
    L2.append(item)
print(L2)
#方法二：使用extend循环li列表内的元素，并加到L2中
L2.extend(li)
print(L2)
		#结果为：['瞎子', '诺克', '德玛', '小黑', '船长', '武器', '螃蟹']
#如果需要加字符串中每个字符，也可以使用extend
li = ["小黑","船长","武器","螃蟹"]
name = "烬劫"
li.extend(name)
print(li)	#结果为['小黑', '船长', '武器', '螃蟹', '烬', '劫']

  4. 删除列表内几个连续的元素

    #删除列表内下标为1-2的值
li = ['瞎子', '诺克', '德玛', '小黑', '船长', '武器', '螃蟹']
del li[1:3]
print(li)	#结果为['瞎子', '小黑', '船长', '武器', '螃蟹']

  5. 将字符串内所有的字符反转打印

    #使用步长方式反转：
li = "小黑半夜三点在玩愤怒的小鸟"
name = li[::-1]
print(name)

#使用while循环方式反转：
L2 = ""
li = "小黑半夜三点在玩愤怒的小鸟"
num = len(li)
index = num - 1
while index >= 0 :
    item = li[index]
    index -= 1
    L2 = L2 + item		# 如果L2是列表的话，则L2.append(item)
print(L2)

#使用for循环方式反转：
li = "小黑半夜三点在玩愤怒的小鸟"
li_len = len(li) - 1
val = ""
for index in range(li_len,-1,-1):
    val += li[index]
print(val)

    range的用法：加入步长，经常与for循环使用。

    print(list(range(0,10,1)))	#结果为[0,1,2,3,4,5,6,7,8,9]
print(list(range(9,-1,-1)))	#结果为[9,8,7,6,5,4,3,2,1,0]

  6. 取出列表中每个元素，并加上索引。根据用户的选择，从1开始对应列表中的元素

    shoping = ['笔记本','游艇','电视','床','茶叶']
for i in range(0,len(shoping)):
    print(i+1,shoping[i])
num = input("请输入你要选择的商品：")
num = int(num)

text = "您选择的是:%s"%(shoping[num-1],)
print(text)

  7. 根据需求完成列表的操作：

    lis = [2,3,"k",["qwe",20,["k1",["tt",3,"1"]],89],"ab","adv"]
#将列表中lis的"k"变成大写，并打印列表
lis[2] = lis[2].upper()
lis[3][0] = lis[3][0].upper()
#将列表中的3修改为字符串“100”
lis[1] = "100"
#将列表中的字符串"tt"变成数字101
lis[3][2][1][0] = 101
#在"qwe"前面插入字符串："火车头"
lis[3].insert(0,"火车头")
print(lis)

  8. 利用for循环和range找出0~100以内的所有偶数，并追加到一个列表中

    #方法一：
val = []
for i in range(0,101,2):
    val.append(i)
print(val)
#方法二：
for i in range(0,101):
    if i % 2 == 0:
        val.append(i)
print(val)

  9. 利用for循环和range找出0~50以内能被3整除的数，并插入到列表中第0个索引位置

    val = []
for i in range(0,51,3):
    val.insert(0,i)
print(val)

  10. 查找列表中的元素，移除每个元素的空格，并找出以"a"(不论大小写)为开头的，添加到一个新列表中，最后循环打印此新列表

    li = ["tianbai","alexC","Abc ","edg","ritian","  WuSir","  anyang"]
new_li = []
for item in li:
    item = item.strip()
    if item.startswith("a") or item.startswith("A"):
        new_li.append(item)
for item in new_li:
    print(item)
print(new_li)

  11. 根据字符串，检索出字符串内所有数字并相加，把数字加入到列表中

    content = "5 + 78+99+ yu+ 53 + 52"
num_list = content.split("+")
print(num_list)
total = 0
new_list = []
for item in  num_list:
    item = item.strip()
    if item.isdigit():
        new_list.append(item)
        total += int(item)
print(new_list)
print(total)
posted @ 2019-09-24 18:43  薛定谔的猫儿  阅读(103)  评论(0)  编辑  收藏  举报