cp4_1_1

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @File  : cp4_1_1.py
# @Author: WRH
# @Date  : 2021/3/9
# @Edition:Python3.8.6

# 第四章：Python的组合数据类型

"""
回忆第一节课的内容
Python中有六个标准的数据类型：

Number（数值）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

# 判断数据类型的方法：type()函数
x = 'a'
print(type(x)) # 输出变量x的数据类型

y = 123
print(type(y)) # 输出变量y的数据类型
"""

# 三种Python组合数据类型：
'''
1.序列类型 （字符串、列表、元组）
字符串(string)：s = 'abc123'
列表(list)：l = ['a', 'b', 'c'] 或 l = [1, 2, 3]
元组(tuple)：t = ('a', 'b', 'c') 或 t = (1, 2, 3)
2.映射类型 （字典）
字典(dictionary)：d = {'a': 1, 'b': 2} 或 d = {} # 空字典
3.集合类型 （集合）
集合(set):
s1 = {1, 2, 3}
s2 = {'a', 'b', 'c'} 
'''

# 序列型组合数据的操作通性
'''
操  作	                    意  义
s1+s2	                    将s1和s2连接成一个序列
s * n                       或 n * s	将序列s复制n次并连接成一个序列
s[i]	                    序列s的第i个元素（从0起算）
s[start : stop : step]	    序列s的第start个元素（含）起至第stop个元素（不含），间隔为step的子序列。若start为0可省略，step为1可省略。
len(s)	                    返回序列s的元素个数（长度）
min(s) 和 max(s)	        返回序列s中最小和最大的元素项,如果值是字母，则按字母顺序进行比较。
s.index(x) 和 s.count(x)	元素x在序列s中第一次出现的位置和出现的次数
x in s 和 x not in s	    判断x是否是序列s的元素，返回布尔值True或False
'''

# 字符串(string)：字符串并不是组合数据类型，因为字符串中的元素只能是字符，但字符串也是一个序列，具有序列的操作通性。
s = 'a1' # 字符串里的元素都是字符
l = ['a', 1] # 列表中的元素既可以是字符，也可以是数值，也可以是别的数据类型
print(type(s)) # 输出变量s的数据类型
print(type(l)) # 输出变量l的数据类型

# 字符串操作举例
s1 = 'xswl'
s2 = '1234'
print(s1 + s2)
print(s1 * 3)
print(s1[0])
print(s1[0:2:1])
print(len(s1))
print(min(s1), max(s2))
print(s1.index('w'), s1.count('w'))
print('l' in s1, 'w' not in s1)

# 1.字符串的索引与切片
# 字符串的索引
'''
利用方括号运算符[ ]可以通过索引值得到相应位置（下标）的字符
格式：s[i]，字符串或者其变量名[索引值]，
从前往后是正向索引，对于总数为n的字符串，其索引值范围为0到n-1
从后向前是负数索引，对于总数为n的字符串，其索引值范围为-1到-n
下标越界会抛出异常
'''
s = 'python'
print(len(s)) # 输出字符串的长度
print(s[0], s[5]) # 输出下标为0和为5的字符，注意下标不能越界
print(s[-1], s[-6]) # 输出下标为-1和为-6的字符，注意下标不能越界
# print(s[6]) # 会报错，因为下标越界了
'''
字符串是不可变对象，不可对字符索引赋值。
s = 'Python'
s[0] = 'p'
'''

# 字符串切片
'''
切片的参数是用两个冒号分隔的三个数字：
格式：s[start : stop : step]，字符串或其变量名[起始数 : 停止数 : 步长]
起始数字表示切片开始位置（默认为0）
停止数字表示切片停止位置（但不包含这个位置，默认为字符串长度）
步长数字表示切片的步长（默认为1），当步长省略时，可以顺便省略最后一个冒号
下标越界不会抛出异常，会在字符串尾部截断或者返回一个空字符串
'''
s = 'Python'
print(s[1:4]) # 切片实际包含索引位置为1～3的字符
print(s) # 切片返回的是字符串的一个副本，原字符串没有发生变化
print(s[:4]) # 省略起始数字，表示切片从默认位置0开始
print(s[1:]) # 省略停止数字，表示切片至默认位置（字符串末尾）结束
print(s[::]) # 省略起始数字、停止数字和步长，都以默认位置执行。
print(s[::2]) # 步长为2
print(s[::-1]) # 步长为-1，得到倒序字符串
print(s[:100]) # 停止位置越界，切片到末尾结束
print(s[100:]) # 起始位置越界，返回空字符串
'''
字符串是不可变对象，不可对字符串切片赋值。
s = 'Python'
s[::] = 'java
'''

# 2.字符串的格式化
# 第一种：用%（格式字符）进行字符串格式化
'''
用%（格式字符）进行字符格式化的一般形式：
format_string % obj
格式字符 % 格式化的对象
'''

# 常见的格式字符
'''
格式字符                  含义	                                    示例
%s	                     输出字符串	                                'Gradeis%s' % 'A-'   返回'GradeisA-'
%d	                     输出整数	                                'Scoreis%d' % 90   返回'Scoreis90'
%c	                     输出字符，传入数字,自动转换为字符，和chr()函数一样	'%c' % 65   返回'A'
                         chr()函数：将一个整数按ASCII码转换为对应的字符。
%[width][.precision]f	 输出浮点数，长度为width，小数点后precision位。   '%f' % 1.23456   返回'1.234560'
                         width默认为0，precision(精度）默认为6          '%.4f' % 1.23456   返回'1.2346'
                                                                    '%7.3f' % 1.23456   返回'  1.235'
                                                                    '%4.3f' % 1.23456   返回'1.235'
%o	                     以无符号的八进制数格式输出	                    '%o' % 10   返回'12'
%x或%X	                 以无符号的十六进制数格式输出	                '%x' % 10   返回'a'
%e或%E	                 以科学计数法格式输出	                        '%e' % 10   返回’1.000000e+01’
'''

print('Gradeis%s' % 'A-')
print('Scoreis%d' % 90)
print('%c' % 65)
print('%f' % 1.23456)
print('%.4f' % 1.23456)
print('%7.3f' % 1.23456)
print('%4.3f' % 1.23456)
print('%o' % 10)
print('%x' % 10)
print('%e' % 10)

s = '我的王者荣耀段位是%s' % '王者'
print(s)

# 如果需要在字符串中通过格式化字符输出多个值，则将每个对应值存放在一对圆括号中，值与值之间用英文逗号隔开
s = '我玩王者%d年了，现在的段位是%s' % (5, '青铜')
print(s)

# 格式化符辅助指令
'''
符号  作用
m    定义输出的宽度，如果变量值的输出宽度超过m,则按实际宽度输出，格式为:%m
-    在指定的宽度内将输出值左对齐（默认右对齐），格式为:%-m
+    在输出的正数前面显示+（默认不输出），格式为:%+m
#    在输出的八进制数前面加0o，在输出的十六进制数前面添加0x或0X，格式为:%#o %#x %#X
0    在指定的宽度内输出值时，左边空格位置以0填充，格式为:%0m
.n   对于浮点数，指输出时小数点后保留的位数（四舍五入），格式为.nf；对于字符串，指输出字符串的前n位，格式为:%.ns
'''

# 例4-1 格式化输出字符串示例。
test = 5000
print("%6d" % test)	# 输出宽度为6，结果为5000（前面有两个空格，右对齐）
print("%2d" % test)	# 输出宽度为2，但test值宽度为4，按实际输出，结果为5000
print("%-6d" % test) # 输出宽度为6，结果为5000  （后面两个空格，左对齐）
print("%+6d" % test) # 输出宽度为6，结果为 +5000（前面一个空格，右对齐）
print("%06d" % test) # 输出宽度为6，结果为005000（前面两个0，空格改为0）
print("%#o" % test) # 以八进制数形式输出，前面添加'0o'，结果为0o11610
print("%#x" % test) # 以十六进制数形式输出，前面添加'0x'，结果为0x1388

test = 128.3656
print("%6.2f" % test) # 输出宽度为6，小数点后面保留2位，结果为128.37
print("%3.1f" % test) # 输出宽度为3，但test值宽度为8，按实际输出，小数点后面保留1位，结果为128.4
print("%.3e" % test) # 小数点后面保留3位，结果为1.284e+02

test = "上海是一个美丽的城市"
print("%5.2s" % test) # 输出宽度为5，输出前两个字，结果为'  上海'（前面有三个空格）

# 第二种用format()方法进行字符格式化

'''
用format()方法进行字符格式化的一般形式：
str.format()
'''
print('我喜欢{0}，她今年{1}岁了。'.format('小瑾', 27)) # 通过数字形式的简单字段名传递位置参数对字符串进行格式化
print('我喜欢{0}。她今年{1}岁了。{0}也喜欢我。'.format('小瑾', 27)) # 数字形式的简单字段名可以重复使用
print('我喜欢{name}。她今年{age}岁了。'.format(name='小瑾', age=27)) # 以接收参数的方式对字符串进行格式化
print('我喜欢{name}。她今年{age}岁了。{name}也喜欢我。'.format(age=27, name='小瑾')) # 参数名可复用，参数的顺序可以随意调换
print('我喜欢{}，她今年{}岁了。'.format('小瑾', 27))  # 若{}中没有变量名或序号，则默认按顺序映射参数。

# 利用{}中的格式限定表达式灵活生成字符
'''
{}中的格式限定表达式通常包括以下可选部分：
{ <序号> : <占位符> <对齐符> <总长度> <千位分隔符> <截断位数> <数字类型> }

<序号>为接收参数的位置顺序，缺省为自然先后顺序，后面冒号通常不要省略；
<占位符>是用于填满整个字符串长度的单个字符；
<对齐符>是参数文本在整个字符串中的对齐方式，^表示居中对齐，<为左对齐，>为右对齐；
<总长度>是生成字符串的总字符数；
<千位分隔符>只用于整数或浮点数,从小数点开始向左每隔三位数字的分隔字符，固定使用,表示；
<截断位数>若用于浮点数或整数则为保留小数点后几位，若用于字符串则为最大输出长度；
<数字类型>包括b(二进制)、c(数字转字符)、d(整数）、o(八进制)、x(十六进制)、X(十六进制)表示整数输出进制或编码字符串，
         .f（浮点数）、e(科学计数）、E(科学计数)、%(百分比)表示浮点数及其指数形式或百分比形式。
'''
print('我的python课程成绩是{:#<20,.2f}。'.format(123456789.1234))
# :后面依次为占位符# 对齐符< 总长度20 千位分隔符, 截断位数.2f保留小数点后两位
print('我的python课程成绩是{0:{2}{1}{3}{4}{5}}。'.format(123456789.1234, '<', '#', 20, ',', '.2f'))
# 对位置在0的参数123456789.123进行格式化，:后面依次为对齐符< 占位符# 总长度20 千位分隔符, 截断位数.2f保留小数点后两位

print('{:>8}'.format('123'))     # 右对齐，总长度8字符
print('{:*^10}'.format('123'))   # 星号填充，居中对齐，总长度10字符
print('{:_^24,}'.format(12345.67890))   # 居中对齐，下画线填充，总长度24字符，千分分隔符为,
print('{:.3f}'.format(1.23456789))    # 保留3位小数
print('{:.3}'.format('甲乙丙丁戊己庚辛'))   # 截断输出3字符
print('{:o}'.format(1234))    # 字符串输出大写十六进制
print('{:e}'.format(0.0000001234)) # 字符串按科学计数法输出
print('{:E}'.format(0.0000001234)) # 字符串按科学计数法输出
print('{:%}'.format(0.12345)) # 输出百分比数字
print('{0:{1}{3}{2}}'.format('甲乙丙丁', '-', 30, '^'))
# 按序号接收参数，对字符串'甲乙丙丁'进行格式化，:后面依次为占位符- 对齐符^ 字符总长度30

# 例4-2
# 字符串综合举例。利用Python内置库calendar，待输入年、月、日后打印输出该日的星期。
import calendar

s = '星期一星期二星期三星期四星期五星期六星期日' # 注意：索引值从0开始
while True:
    y = input('请输入年，x为退出\n')
    if y in ('x', 'X'): # 设置退出程序的输入符号x或X
        break # 退出循环
    else:
        m = input('请输入月\n')
        d = input('请输入日\n')
        i = calendar.weekday(int(y), int(m), int(d))  # 星期几对应的数字
        # 因为input()函数返回的数据总是字符串，所以要用int()函数将输入的数据类型转换为整数
        print('您所输入的日期{0}年{1}月{2}日是：{3:>5}'.format(y, m, d, s[i * 3:i * 3 + 3]))
        # {0}对应y {1}对应m {2}对应d {3:>5}对应s[i * 3:i * 3 + 3]
        # {3:>5}表示接收参数位置为3，即s[i * 3:i * 3 + 3]，格式化限定格式为 >（右对齐） 5（字符总长度为5）
        # s[i * 3:i * 3 + 3]，表示对字符s进行切片，因为i为0，
        # 所以s[i * 3:i * 3 + 3] == s[0:3]，抽取s字符串的0-3字符为星期一

# weekday()方法的简介
'''
weekday()方法是Python中日历模块的内置方法。
它适用于简单的文本日历，并返回函数参数中给定的年，月和日的星期几的数字，
在这里，星期一对应的数字是0，依次类推，星期日对应的数字是6。
'''

import calendar

week = ['Monday', "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] # 注意：索引值从0开始
year = 2021
month = 3
day = 15
week_num = calendar.weekday(year, month, day) # 星期几对应的数字
print("Weekday number:", week_num) # 输出星期几对应的数字
print("Weekday name:", week[week_num]) # 输出星期几