python+AI第四课

切片

对序列截取一部分的操作，（字符串，列表，元组都支持）

• 格式：对象[start: end: step]左闭右开,省略start代表从零开始，end省略代表包括最后，step省略代表步长1

l1 = [i for i in range(10)]
print(l1)
print(l1[2:7])
#[2, 3, 4, 5, 6]
print(l1[2:])
#[2, 3, 4, 5, 6, 7, 8, 9]
print(l1[0: 4: 2])
#[0, 2]
print(l1[0: -2])
#[0, 1, 2, 3, 4, 5, 6, 7]
print(l1[-4: -2])
#[6, 7]
print(l1[-4: 2])
#[]
print(l1[-1: -3: -1])
#[9, 8]
print(l1[-1: 1: -1])
#[9, 8, 7, 6, 5, 4, 3, 2]
print(l1[3: 1: -1])
#[3, 2]
print(l1[3: -3: -1])
#[]
print(l1[: :])
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[:])
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[: : -1])
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

• 使用切片原地修改列表的内容

a = [3, 5, 7]
a[len(a):] = [9]
print(a)
#[3, 5, 7, 9]

a[:3] = [1, 2, 3]
print(a)
#[1, 2, 3, 9]

a[:3] = [ ]
print(a)
#[9]

• 使用del和切片结合删除列表的元素

a = [1, 2, 3, 9, 11]
del a[0]
print(a)
#[2, 3, 9, 11]
del a[ : :2]
print(a)
#[2, 9]

• 浅复制：
  指生成一个新的列表，并且把原列表中所有元素的引用都复制到这个新的列表中

其中‘=’赋值：数据完全共享（复制数据，数据内存共享）

alist = [3, 5, 7]
blist = alist
blist[1] = 8
print(alist)
#[3, 8, 7]
print(id(alist))#查看元素内存地址
#1918416
print(id(blist))
#1918416
print(alist == blist)#判断两个列表中元素是否一样
#True
print(alist is blist)#判断两个列表是否是同一个对象
#True

切片:
数据半共享（只复制数据，数据内存独立存放），浅复制

alist = [3, 5, 7]
blist = alist[ : : ]
print(alist == blist)
#True
print(alist is blist)
#False
print(id(alist))
#5719504
print(id(blist))
#5720664

元组

元组tuple属于不可变的序列， 一旦创建，用任何方法都不能将其修改（）表示

a = (1, 2, 3)
print(type(a))
#<class 'tuple'>
#创建只有一个元素的元组
x = (3, )#如果没有逗号就返回int类型
print(type(x))
#<class 'tuple'>

使用tuple函数将其他序列转化为元组
列标转化成元组
一。

from random import randint
a = [randint(-10, 10) for _ in range(10)]
print(a)
#[-1, 3, 6, -6, 4, -4, -10, 5, -4, -5]
print(tuple(a))
#(-1, 3, 6, -6, 4, -4, -10, 5, -4, -5)

二。

#range函数
print(list(range(6)))
#[0, 1, 2, 3, 4, 5]
print(tuple(range(6)))
#(0, 1, 2, 3, 4, 5)

三。

#字符串
import string
print(string.ascii_lowercase[ : 7])
#abcdefg
print(tuple(string.ascii_lowercase[ : 7]))
#('a', 'b', 'c', 'd', 'e', 'f', 'g')

元组和列表的区别:
1.元组中数据一旦定义就不允许修改
2.元组中没有append，extend，insert等方法，不能向原著中添加元素
3.元组中也没有删除相关方法，不能从元组中删除元素
4.从效果上看，tuple函数是冻结列表的，list函数是融化列表的

元组优点

• 速度比列表快
• 对数据进行“写保护”让代码更加安全
• 可以用作字典的键，还可以作为函数的返回值返回（多个值）

字符串

• 字符串的切片

import string
letters = string.ascii_uppercase[ : 9]
print(letters)
#ABCDEFGH
print(letters[3])
#D
print(letters[2: 4])
#CD
print(letters[ : ])
#ABCDEFGHI
print(letters[-2: ])
#HI
print(letters[-2: 2])
#空

字符串常用操作方法
1.upper，lower 字符串全部大写或小写
常用指数

str1 = 'www.NEUEDU.com'
str1.upper()#全大写
str1.lower()#全小写
print(str1.startswith('www'))#判断字符串是否以prefix开头
print(str1.startswith('www', 0, 4))#左闭右开
print(str1.endswith('.com'))

2.startswith，endswith 判断字符串是否以prefix开头或结尾
常用指数

print(str1.startswith('www'))#判断字符串是否以prefix开头
print(str1.startswith('www', 0, 4))#左闭右开
print(str1.endswith('.com'))

3. find， index 查找元素
   获取指定元素首次出现的下标
   常用指数

str1 = 'www.NEUEDU.com'
print(str1.find('h'))
#-1
print(str1.find('w'))
#0
print(str1.index('N'))
#4
print(str1.index('h'))
#找不到会报错
print(str1.rfind('w'))
#2 r表示从右边开始找，返回下标是正常顺序
print(str1.rindex('w'))
#2

4.strip 默认去除字符前后两端的空格，换行，tab
常用指数

str1 = '  \n www.NEUEDU.com  \t '
print(len(str1))
#22
print(len(str1.strip()))
#14 空格全都去掉了
str2 = 'aabbccddff'
str2 = str2.strip('aa')
print(str2)
#bbccddff aa去掉了
str2 = str2.rstrip('ff')#去掉指定一端ff若该端没有，就返回原来的str
#bbccdd
str2 = str2.lstrip('ff')
    bbccddff

5.splid 把字符串分割成列表，默认是以空格进行分割
常用指数

str1 = ' life; is; short, use; Python'
print(str1.split())
#['life', 'is', 'short,', 'use', 'Python']
print(str1.split(','))
#[' life is short', ' use Python']
print(str1.split(';', 3))#指定按多少个';'分割
name = '12neu\nsoft12333'
print(name)
# 12neu
# soft12333
print(name.splitlines())
# ['12neu', 'soft12333']
#按照行分

6.join 把列表转化成字符串
常用指数

str1 = ' life is short, use Python'
l1 = str1.split()
s1 = ' '.join(l1)
print(s1)
#life is short, use Python
s1 = '='.join(l1)
print(s1)
#life=is=short,=use=Python
s1 = '\\'.join(l1)
print(s1)
#life\is\short,\use\Python
s1 = '/'.join(l1)
print(s1)
#life/is/short,/use/Python

7.is 系列
常用指数

name = 'Neusoft123'
print(name.isalnum())#判断是否是数字或字母
print(name.isdigit())#数字
print(name.isalpha())#字母
print(name.islower())#小写
print(name.isupper())#大写
print(name.istitle())#首字母大写
print(name.isspace())#空白

8.count 计数
常用指数

name = 'Neusoft12333'
print(name.count('3'))
#3

9.replace 替换指定字符
常用指数

name = '12333Neusoft12333'
print(name.replace('N', ' '))
#12333 eusoft12333
print(name.replace('12333', '', 1))
#Neusoft12333

10.capitalize首字母大写
常用指数

name = 'neusoft12333'
print(name.capitalize())
#Neusoft12333

11.center, rjust, ljust 字符串居中
常用指数

#参数可以设置字符串的总长度，可以使用*进行填充
name = 'neusoft12333'
print(name.center(20, '*'))
#****neusoft12333****
s1 = 'neuedu'
print(len(s1))
print(s1.rjust(20))
#              neuedu
print(s1.ljust(20))
print(s1.ljust(20, '*'))
#neuedu**************

12.title 非字母隔开的每个单词的首字母大写
常用指数

s = 'chen wuang4fhsa￥fh。f'
print(s.title())
#Chen Wuang4Fhsa￥Fh。F

13.partition 将字符串分成三部分
常用指数

name = '12neusoft12333'
print(name.partition('ft'))
#('12neuso', 'ft', '12333')
print(name.rpartition('12'))
#('12neusoft', '12', '333')

字典

包含若干键值对的无序可变序列
字典中的键可以为任意的不可变的数据（number，string，tuple）

• 创建字典

d = {'server': 'db.neuedu.com', 'database': 'oracle'}
print(type(d))
# <class 'dict'>
print(d)
# {'server': 'db.neuedu.com', 'database': 'oracle'}

• 使用dict函数将已有数据转化成字典
  方法1

import string
keys = [x for x in string.ascii_lowercase[ : 5]]
values = [i for i in range(1, 6)]
print(dict(zip(keys, values)))
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

方法2：
使用dict根据给定的键值创建

d3 = dict(name='wunan', age=18)
print('d3', d3)
#d3 {'name': 'wunan', 'age': 18}

方法3：
根据给定的内容为键创建值为空的字典

print(dict.fromkeys(['name', 'age', 'gender']))
# {'name': None, 'age': None, 'gender': None}

• 字典的读取
  ①.字典名['键'],以键作为下标读取字典元素，不存在这个键就会抛出异常
  ②.使用d.get方法获取指定键对应的值，并且可以为不存在的键指定默认返回值

print(d3['name'])
#wunan
print(d3.get('name'))
#wunan
print(d3.get('f'))
#None
print(d3.get('addr', '内蒙古'))
# 内蒙古

③.获取字典所有的键，返回包含这个字典所有键的列表

print(d3.keys())
#dict_keys(['name', 'age'])
print(list(d3.keys()))
# ['name', 'age']

④.获取字典所有的值，返回包含这个字典所有值的列表

print(d3.values())
# dict_values(['wunan', 18])
print(list(d3.values()))
# ['wunan', 18]

⑤.获取字典所有的键，值

print(d3.items())
#dict_items([('name', 'wunan'), ('age', 18)])
l3 = d3.items()

print(dict(l3))
# {'name': 'wunan', 'age': 18}

• 字典的修改

d3 = dict(name='wunan', age=18, gender='female')
字典名['键'] = '新的值'
d3['gender'] = 'male'
print(d3)
# {'name': 'wunan', 'age': 18, 'gender': 'male'}

• 字典的添加

字典名['不存在的键'] = '新的值'

当字典中存在这个键进行赋值时是修改操作
当字典中不存在这个键进行赋值时是添加操作

d3['addr'] = '内蒙古'
print(d3)
# {'name': 'wunan', 'age': 18, 'gender': 'male', 'addr': '内蒙古'}

• 字典的删除
  ①.del 可以删除整个字典，或者其中的指定元素

del d3
print(d3)
#都没了
根据键删除
del d3['addr']
print(d3)
{'name': 'wunan', 'age': 18, 'gender': 'male'}

②.clear清除字典的所有数据

d3.clear()
print(d3)
#{}

③.pop，popitem 删除指定键所对应的值， 返回这个值并从字典中把它移除

# ret = d3.pop()
# print(ret)
# print(d3)
#按照后进先出的顺序返回并删除字典的最后的键值对
d3.popitem()
# in 判断一个key是否在字典中
print ('name'  in d3.keys())
print ('name' in d3)

• 字典的遍历
  ①遍历所有的键

for key in d3.keys():
    print(key)

②遍历所有的值

for v in d3.values():
    print(v)

③遍历所有的项

for kv in d3.items():
    print(kv)

④遍历所有的键值

for k, v in d3.items():
    print(k, v)

• 有序字典 可以使用collection模块的

from collections import OrderedDict
#  创建一个无序字典
# x = {}
# x['b'] = 3
# x['a'] = 1
# x['c'] = 5
# print(x)
x = OrderedDict()
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(dict(x))

• 字典推导式 （字典解析）

# [i for i in range(10)]
# {k: v for 临时变量 in 迭代对象 if 条件}
from random import randint
# {'student1':90,'student2':90,'student3':90,}  20 名学生
# l1 = [randint(0, 101) for _ in range(1, 21)]
grade = {'student{}'.format(x): randint(0, 101) for x in range(1, 11)}
# print(l1)
print(grade)

# 使用字典解析筛选 大于60分成绩的学生
jiege = {}
for k,v in grade.items():
    if v > 60:
        jiege[k] = v
print(jiege)

jiege = {k:v for k, v in grade.items() if v>60}
print(jiege)

• strings =

['import','is','with','if','file','exception','liuhu']

用字典推导式以字符串以及其索引位置建字典
①.

print({val: index for index, val in enumerate(strings)})

②.

print({strings[i]: i for i in range(len(strings))})

③.

print({v: len(v) for v in strings})

• 合并
  同一个字母但不同大小写的值合并起来了

mc = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

都合并到小写

print({k.lower(): mc.get(k.lower(), 0)+mc.get(k.upper(),0) for k in mc.keys()})

集合

• 无序不重复
• 只能包含不可变数据（数字、字符串、元组）
  创建

b = {3,6,7,9}
print(type(b))
#<class 'set'>
print(b)
#{9, 3, 6, 7}

添加

b.add('8')
print(b)
#{3, 6, 7, 9, '8'}

将其他数据类型转化为集合

a = set(range(10))
print(a)
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
c = set([i for i in range(25)])
print(c)
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}
del c
print(c)# name 'c' is not defined
# update方法
d = {3, 5, 4}
# d.update({5, 7, 4})
print(d)
# {3, 4, 5}

pop() 弹出并删除其中的一个元素

d = {3, 5, 4}
v = d.pop()
print(v)
#3
print(d)
#{4, 5}

删除指定元素的值

d.remove(5)
print(d)
#{4}

清空集合

d.clear()
print(d) 
#{}

使用集合快速提取序列中单一元素

from random import choice
# 随机选取序列中的一个元素
# print(choice(['a', 'b', 'c']))
# print(choice('dwfjio'))
random_list = [choice(range(100)) for _ in range(200)]
print(random_list)
print(len(random_list))
#200

生成一个norepeat的集合

noRepeat = []
for x in random_list:
    if x not in noRepeat:
        noRepeat.append(x)
print(len(noRepeat))
noRepeat = set(noRepeat)
print(noRepeat)

集合解析

# 将列表转化为集合，并且做每个元素两端去空格处理
s = ['    ddd', '   is  ', '    python   ']
print({x.strip() for x in s})
#{'is', 'ddd', 'python'}

作业：
1.(模拟龟兔赛跑)本练习中要模拟龟兔赛跑的寓言故事。用随机数产生器建立模拟龟兔赛跑的程序。 对手从70个方格的第1格开始起跑，每格表示跑道上的一个可能位置，终点线在第70格处。 第一个到达终点的选手奖励一个新鲜萝卜和莴苣。兔子要在山坡上睡一觉，因此可能失去冠军。 有一个每秒钟滴答一次的钟，程序应按下列规则调整动物的位置：

image
用变量跟踪动物的位置(即位置号1到70)。每个动物从位置1开始，如果动物跌到第1格以外，则移回第1格。 产生随机整数1≤i≤10)，以得到上表中的百分比。对于乌龟，1≤i≤5时快走，6≤i≤7时跌跤，8≤i≤10时慢走，兔子也用相似的方法。 起跑时，打印： BANG !!!!! AND THEY' RE OFF !!!!! 时钟每次滴答一下(即每个重复循环)，打印第70格位置的一条线，显示乌龟的位置T和兔子的位置H。 如果两者占用一格，则乌龟会咬兔子，程序从该位置开始打印 OUCH!!!。除T、H和OUCH!!!以外的其他打印位置都是空的。 打印每一行之后，测试某个动物是否超过了第70格，如果是,则打印获胜者，停止模拟。 如果乌龟赢，则打印TORTOISE WINS!!!YAY!!!。如果兔子赢，则打印Hare wins．Yush。 如果两个动物同时赢，则可以同情弱者，让乌龟赢，或者打印It's a tie。如果两者都没有赢，则再次循环，模拟下一个时钟滴答。 准备运行程序时，让一组拉拉队看比赛，你会发现观众有多么投入。

# -*- coding:utf-8 _*-
# @Time    : 公元 2019/11/07 21:08
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : demo5.py
# @Software: PyCharm
from random import randint

print("BANG !!!!! AND THEY' RE OFF !!!!! ")
n = 1
hPos = 0#兔子坐标
tPos = 0#乌龟坐标
while n == 1:
    runway = '-'*70
    i = randint(0, 10) + 1
    #龟
    if i <= 5:
        tPos += 3
    elif 5 < i <= 7:
        tPos -= 6
        if tPos <= 1:
            tPos = 1
    else:
        tPos += 1
    #兔
    if i <= 2:
        hPos = hPos
    elif 3 <= i <= 4:
        hPos += 9
    elif i == 5:
        hPos -= 12
        if hPos <= 1:
            hPos = 1
    elif 6 <= i <= 8:
        hPos += 1
    else:
        hPos -= 2
        if hPos <= 1:
            hPos == 1

    if tPos >= 70 or hPos >= 70:
        n = 2

    if tPos == hPos:
        runway = runway[:tPos] + 'OUCH!!!' + runway[tPos+5:]
        #除去字符串OUCH!!!长度，补上TH长度占位，T跟H在同一个位置
    else:
        runway = runway[:tPos] + 'T' + runway[tPos:]
        runway = runway[:hPos] + 'H' + runway[hPos:]
    print(runway)

if tPos >= 70:
    print("TORTOISE WINS!!!YAY!!!")

elif hPos >= 70:
    print("Hare wins．Yush。")

else:
    print("it's a tie")

2.需求

给定单词数组（不少于10个），程序随机选择其中的一个，并显示单词字符长度个横线（-），用户有5次猜测机会，用户每次猜一个字母，如果正确，则将在相应的位置上显示出来；如错误则猜测机会减一，重复该过程，直至单词的全部字母全部猜出或者猜测次数用完，最后宣布用户胜利或失败。

实例

例如随机选出的单词是apple，程序先打印- - - - - 用户输入p，程序打印 -pp-- 用户输入e，程序打印 -pp-e 用户输入t，程序打印 -pp-e 您还有4次机会 用户输入a，程序打印 app-e 用户输入l，程序打印 apple 恭喜您，取得胜利。

# -*- coding:utf-8 _*-
# @Time    : 公元 2019/11/07 21:08
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : demo5.py
# @Software: PyCharm

import random
words = ['pen', 'water', 'banana', 'range', 'apple', 'lemon', 'cherry', 'pear', 'coconut', 'peach']
word = words[random.randint(0,len(words) - 1)]
list1 = list('_'*len(word))

print('_'*len(word))

n = 1
while n < 6:
    guess = input(f"请输入一个字母,您还有{6-n}次机会")
    if guess in word:
        for i, c in enumerate(word):
            if c == guess:
                list1[i] = guess
        print("".join(list1))
        l2 = "".join(list1)
        if "_" not in l2:
            print("恭喜您全猜对了，胜利！")
            break
    n += 1

if n == 6:
    print("没有机会了，挑战失败")