#使用字符串
def strings():
str1 ="hello,world!"
#len(str)获取字符串长度
print(len(str1))#12
#获得首字母大写的拷贝
print(str1.capitalize())#Hello,world！
#获得字符串变大写后的拷贝
print(str1.upper())#HELLO,WORLD！
#从字符串中查找字符字串的位置
print(str1.find("or"))#7
print(str1.find("shit"))#-1
#与find类似但是找不到子串会引发异常
print(str1.index("or"))#7
#print(str1.index("shit"))#异常
#检查字符串是否以指定的字符串开头
print(str1.startswith("He"))#False
print(str1.startswith("hel"))#True
#检查字符串是否与指定的字符串结尾
print(str1.endswith("!"))#True
#将字符串与指定的宽度居中并在两侧填充指定的字符
print(str1.center(50,"*"))# *******************hello,world!*******************
#将字符串以指定的宽度靠右放置左侧填充指定的字符串
print(str1.rjust(50,"-"))#--------------------------------------hello,world!
str2 ="abc123456"
print(str2[2])#c
#字符串切片（从指定的开始索引到指定的结束索引）
print(str2[2:5])#c12
print(str2[2:])#c123456,第二个数省略表示到末尾
print(str2[2::2])#c246,步长为2算到最后
print(str2[::2])#ac246,步长为2，从第一个开始到最后
print(str2[::-1])#654321cba ，逆序输出,步长为--1
print(str2[-3:-1])#45 加上负号之后是从后往前算
print(str2[:])#abc123456,输出整个字符串
#检查字符串是否由数字构成
print(str2.isdigit())#FALSE
print(str2.isalpha())#false
print(str2.isalnum())#true
str3= " yuxiaojun@163.com "
print(str3)# yuxiaojun@163.com
#获得字符串修剪左右两侧空格的拷贝
print(str3.strip())#yuxiaojun@163.com
----------------------------------------------------------
12
Hello,world!
HELLO,WORLD!
7
-1
7
False
True
True
*******************hello,world!*******************
--------------------------------------hello,world!
c
c12
c123456
c246
ac246
654321cba
45
abc123456
False
False
True
yuxiaojun@163.com
yuxiaojun@163.com
___________________________________________________________
#使用列表
"""
"""
list1 =[1,3,5,7,9]
print(list1)
list2 =["hello"]*5 #重复5次hello
print(list2)
#计算列表长度
print(len(list1))#5
#下标（索引）运算
print(list1[1])#3
print(list1[4])#9
print(list1[-1])#9,从逆序算，最后一个元素是-1
print(list1[-3])#5
list1[2]=100 #list可以赋值更改
print(list1)#[1, 3, 100, 7, 9]
#添加元素
list1.append(200)#添加到最后
list1.insert(1,400)#插入到指定位置
print(list1)
print(len(list1))
list1+=[1000,2000]*2# 在最后加入新的list
print(list1)
print(len(list1))
#删除元素
list1.remove(1000)#移除第一个值为x的数，参数为列表数值元素
if 1234 in list1:
list1.remove(1234)
del list1[0]#删除第x个元素，参数为列表元素下标
print(list1)
#清空列表元素
list1.clear()
print(list1)
#和字符串一样，列表也可以做切片操作
fruits =["grape","apple","strawberry","waxberry"]
print(fruits)
fruits+=["pitaya","pear","mango"]#在列表后面增加元素
print(fruits)
for fruit in fruits:
#fruit.title()元素的标题
print(fruit.title(),end="\t")#遍历输出元素 Grape Apple Strawberry Waxberry Pitaya Pear Mango
print()
#列表切片
fruits2 =fruits[1:4]#['apple', 'strawberry', 'waxberry']，含首不含尾
print(fruits2)
fruits3 = fruits
fruits4 =fruits[:]
print(fruits4)
fruits5 = fruits[-3:-1]#['pitaya', 'pear']
print(fruits5)
fruits6 =fruits[::-1]#逆序遍历 ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
print(fruits6)
---------------------------------------------------
[1, 3, 5, 7, 9]
['hello', 'hello', 'hello', 'hello', 'hello']
5
3
9
9
5
[1, 3, 100, 7, 9]
[1, 400, 3, 100, 7, 9, 200]
7
[1, 400, 3, 100, 7, 9, 200, 1000, 2000, 1000, 2000]
11
[400, 3, 100, 7, 9, 200, 2000, 1000, 2000]
[]
['grape', 'apple', 'strawberry', 'waxberry']
['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
Grape Apple Strawberry Waxberry Pitaya Pear Mango
['apple', 'strawberry', 'waxberry']
['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
['pitaya', 'pear']
['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
#对列表进行排序
def sortlist():
list1 =["orange","apple","zoo","blueberry"]
#sorted()函数返回列表排序后的拷贝不会修改传入的列表
list2 =sorted(list1)#按首字母进行排序
list3 =sorted(list1,reverse=True)#排序后翻转
list4 =sorted(list1,key=len)#按长度排序
print(list1)
print(list2)
print(list3)
print(list4)
#sort函数直接在列表对象上进行排序
list1.sort()
print(list1)
list1.sort(reverse=True)#排序后翻转
print(list1)
sortlist()
--------------------------------------------------
['orange', 'apple', 'zoo', 'blueberry']
['apple', 'blueberry', 'orange', 'zoo']
['zoo', 'orange', 'blueberry', 'apple']
['zoo', 'apple', 'orange', 'blueberry']
['apple', 'blueberry', 'orange', 'zoo']
['zoo', 'orange', 'blueberry', 'apple']
"""
生成式语法
使用列表的生成式语法来创建列表
"""
import sys
listf =[x for x in range(1,10)]#x在1-10里面取，
print(listf)
listf =[x+y for x in "ABCDE" for y in "1234567"]#第一个元素取自x，第二个元素取自y,组成新的元素
"""
['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2',
'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
"""
print(listf)
#用列表的生成式表达式语法创建列表容器
#用这种语法创建列表之后元素已经准备就绪所以需要消耗较多的内存空间
listf =[x**2 for x in range(1,10)]#[ ]
print(sys.getsizeof(listf))#100 查看对象占据内存的字节数
print(listf)
"""
请注意下面的代码创建的不是一个列表而是一个是生成器对象
通过生成器可以获取数据但是它不占用额外的内存空间存储数据
每次需要数据的时候就通过内部的运算得到数据
"""
listf =(x**2 for x in range(1,20))#x取自1-9，然后x**2作为列表元素#( )
print(sys.getsizeof(listf))# 48 查看对象占据内存的字节数
print(listf)
for var in listf:
print(var)
------------------------------------------------------------
[1, 2, 3, 4, 5, 6, 7, 8, 9]
['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
100
[1, 4, 9, 16, 25, 36, 49, 64, 81]
48
<generator object <genexpr> at 0x05262EA0>
1
4
9
16
25
36
49
64
81
100
121
144
169
196
225
256
289
324
361
"""
Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数
"""
def fib(n):
a,b = 0,1
for _ in range(n):
a,b =b,a+b
yield a #生成器函数
#print(a)
def list1():
for var in fib(20):
print(var)
list1()
--------------------------------
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
#使用元祖
"""
元组的元素不能修改
把多个元素组合到一起就形成了一个元组
和列表一样可以保存多条数据
元组在创建时间和占用的空间上面都优于列表
"""
#定义元组
t =("yu","xiao","jun",23,True,"南昌","jxnu")
print(t)
#获取元组元素
print(t[2])
print(t[4])
#遍历元组中的值
for member in t:
print(member)
#重新给元组赋值
#t[0] ="wang"#TypeError
#变量t重新引用了新的元组原来的元组将被垃圾回收
t=("王大锤",20,True,"yunnan")
print(t)
#将元组转换成列表
list = list(t)
print(list)
#列表的元素可修改
list[0]="Li"
list[1]="25"
print(list)
#将列表转换成元组
fruits_list = ["apple","banana","orange"]
fruits_tuple =tuple(fruits_list)
print(fruits_tuple)
-------------------------------------------------------------------------------
('yu', 'xiao', 'jun', 23, True, '南昌', 'jxnu')
jun
True
yu
xiao
jun
23
True
南昌
jxnu
('王大锤', 20, True, 'yunnan')
['王大锤', 20, True, 'yunnan']
['Li', '25', True, 'yunnan']
('apple', 'banana', 'orange')
#使用集合
#不允许有重复元素，而且可以进行交集、并集、差集等运算
set1={1,2,3,3,3,2,4,5,6,7}
print(set1)#{1, 2, 3, 4, 5, 6, 7}
print("length=",len(set1))#7
set2=set(range(1,10))#{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set2)
set1.add(18)
set1.add(19)#{1, 2, 3, 4, 5, 6, 7, 18, 19}
set2.update([11,12])#{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
print(set1)
print(set2)
set2.discard(12)#{1, 2, 3, 5, 6, 7, 8, 9, 11} 去除12
#remove 元素如果不存在会引发KeyError错误
if 4 in set2:
set2.remove(4)
print(set2) #{1, 2, 3, 5, 6, 7, 8, 9, 11}
#遍历集合容器
for elem in set2:
print(elem**2,end=" ")# 1 4 9 25 36 49 64 81 121
print()
#将元组转换为集合
set3 =set((1,2,3,3,2,1,4,5,6,7))#注意这里双重括号，里层代表元组，外出代表函数
print(set3.pop())#集合元素出来
print(set3)#{2, 3, 4, 5, 6, 7}
#集合的交集，并集，差集，对称差运算
print(set1)
print(set2)
print(set1&set2)#交集
print(set.intersection(set2))
print(set1|set2)#并集
print(set1.union(set2))
print(set1-set2)#差集
print(set1.difference(set2))
print(set1^set2)#对称差集
print(set1.symmetric_difference(set2))
#判断子集和超集
print(set1<=set2)#子集
print(set2.issubset(set1))#子集 set2的子集是否是set1
print(set1>=set2)#超集
print(set1.issuperset(set2))#超集 set1的超级是否是set2
----------------------------------------------------------------------------
{1, 2, 3, 4, 5, 6, 7}
length= 7
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5, 6, 7, 18, 19}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
{1, 2, 3, 5, 6, 7, 8, 9, 11}
1 4 9 25 36 49 64 81 121
1
{2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7, 18, 19}
{1, 2, 3, 5, 6, 7, 8, 9, 11}
{1, 2, 3, 5, 6, 7}
{1, 2, 3, 5, 6, 7, 8, 9, 11}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 18, 19}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 18, 19}
{18, 19, 4}
{18, 19, 4}
{4, 8, 9, 11, 18, 19}
{4, 8, 9, 11, 18, 19}
False
False
False
False
#使用字典
"""
字典是另一种可变容器模型，类似于我们生活中使用的字典
可以存储任意类型对象
字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开
"""
scores ={"li":95,"hu":97,"yu":99,"chen":98}
#通过键获得字典中对应的值
print(scores["li"])
print(scores["yu"])
#对字典进行遍历(键值对通过键取得相应的值)
for elem in scores:
print(elem,scores[elem])
print("%s--->%d"%(elem,scores[elem]))
#更新字典中的元素
scores["li"]=100
scores["yu"]=100
scores.update(qiu=86,cai=95)#添加新的键值对进入字典中
print(scores)
#通过遍历键取得值
if "yu" in scores:
print(scores["yu"])
#get方法通过键获取对应的值
print(scores.get("yu"))
#删除字典中的元素
print(scores.popitem())#删除最后一个字典
print(scores.popitem())
print(scores.pop("chen"))#删除键为"chen"的元素，并输出键值
print(scores)
#清空字典
scores.clear()
print(scores)
-------------------------------------------------
95
99
li 95
li--->95
hu 97
hu--->97
yu 99
yu--->99
chen 98
chen--->98
{'li': 100, 'hu': 97, 'yu': 100, 'chen': 98, 'qiu': 86, 'cai': 95}
100
100
('cai', 95)
('qiu', 86)
98
{'li': 100, 'hu': 97, 'yu': 100}
{}
#1、在屏幕上显示跑马灯文字
#有意思
import os
import time
def run():
content =" i love yu xiao jun "
while True:
#清理屏幕上的输出
os.system("cls") #os.system("clear")
print(content)
#休眠0.2s
time.sleep(0.2)
#控制字体循环前移（左移）一个字符
content = content[1:]+content[0]
run()
#2、设计一个函数产生指定长度的验证码。验证码由大小写字母和数字组成
import random
#默认长度为8
def generate_code(code_len=8):
all_chars ="0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"#所有的可以取得的字符
long=len(all_chars)-1#字符总长度
code =" "
for i in range(code_len):
index = random.randint(0,long)#产生随机长度
code+=all_chars[index]#随机下标对应相应的字符加入code中
return code
generate_code(26)
#3、设计一个函数返回给定文件名的后缀名
def get_suffix(filename,has_dot=False):
pos =filename.rfind(".")#返回指定字符的位置
if 0<pos <len(filename)-1:
index = pos if has_dot else pos+1
return filename[index:]
else:
return ' '
get_suffix("B2.CPP")
#4、设计一个函数返回传入的列表中最大和第二大的元素的值
def max2(x):
#m1存放最大,m2存放第二大的元素
m1,m2 =(x[0],x[1]) if x[0]>x[1] else (x[1],x[0])
for index in range(2,len(x)):
if x[index]>m1:#大于最大的元素
m2 =m1 #第二大的元素被更换
m1 =x[index] #第一大的元素被更换
elif x[index]>m2:#大于第二大的元素
m2 =x[index] #第二大的元素被更换
return m1,m2 #返回最大的和第二大的
list =[1,1,2,3,4,5,6,7,3,5,354,2,4,65,7,435,2]
max2(list)
_
#6、打印杨辉三角
#没看太懂
def print_yanghui():
num =int(input("number of rows:"))
yh =[[]]*num#??????
for row in range(len(yh)):
yh[row]=[None]*(row+1)
for col in range(len(yh[row])):
if col==0 or col==row:
yh[row][col] =1
else:
yh[row][col] = yh[row-1][col]+yh[row-1][col-1]
print(yh[row][col],end="\t")
print()
print_yanghui()
#综合 双色球选号
from random import randrange,randint,sample
def display(balls):
#输出列表中的双色球
for index,ball in enumerate(balls):
if index ==len(balls)-1:
print("|",end =" ")
print("%2d"%ball,end=" ")
print()
def random_select():
#随机选择一组号码
red_balls =[x for x in range(1,34)]
selected_balls=[]
selected_balls = sample(red_balls,6)
selected_balls.sort()
selected_balls.append(randint(1,16))
return selected_balls
n =int(input("选择几注:"))
for _ in range(n):
display(random_select())
#综合 约瑟夫环问题
"""
有15个基督徒和15个非基督徒在海上遇险，为了能让一部分人活下来不得不将其中15个人扔到海里面去,
有个人想了个办法就是大家围成一个圈，由某个人开始从1报数，报到9的人就扔到海里面，他后面的人
接着从1开始报数，报到9的人继续扔到海里面，直到扔掉15个人。由于上帝的保佑，15个基督徒都幸
免于难，问这些人最开始是怎么站的，哪些位置是基督徒哪些位置是非基督徒。
"""
persons =[True]*30
counter,index,number = 0,0,0
while(counter<15):
if persons[index]:
number+=1
if number==9:
persons[index]=False
counter+=1
number=0
index+=1
index%=30
for person in persons:
print("基" if person else " 非",end = " ")
#综合 井字棋游戏
#等待完善
import os
def print_board(board):
print(board["TL"] + "|" + board["TM"] + "|" + board["TR"])
print("-+-+-")
print(board["ML"] + "|" + board["MM"] + "|" + board["MR"])
print("-+-+-")
print(board["BL"] + "|" + board["BM"] + "|" + board["BR"])
def game():
init_board ={"TL" : ' ',"TM" : ' ',"TR" : ' ',
"ML" : ' ',"MM" : ' ',"MR" : ' ',
"BL" : ' ',"BM" : ' ',"BR" :' '}
begin =True
while begin:
curr_board = init_board.copy()
begin=False
turn ="x"
counter = 0
os.system("clear")
print_board(curr_board)
while counter<9:
move = input("轮到%s走棋,请输入位置："%turn)
if curr_board[move] ==" ":
counter+=1
curr_board[move] =turn
if turn =="x":
turn ="o"
else:
turn ="x"
os.system("clear")
print_board(curr_board)
choice = input("再玩一局？(yes|no)")
begin =choice=="yes"
game()