赞
踩
如果在程序中用到了中文,直接输出结果很可能会出错,比如:
print("你好")
解决的办法是,在程序的开头写入如下代码:
# -*- coding:utf-8 -*-
或者
# coding=utf-8
用于向 Python 解释器声明源代码文件所用的编码类型为“utf-8”,如果代码里有中文,打印的时候可以使中文正常显示。
Python 中的注释包括单行注释和多行注释。
Python 中单行注释以 # 开头:
# 第一个注释
print("Hello World") # 第二个注释
执行以上代码,输出结果为:
Hello World
Python 中多行注释可以用多个 # 开头,或者用 ‘’’ 和 “”" 双引注释内容:
# 第一个注释
# 第二个注释
'''
第三个注释
第四个注释
'''
"""
第五个注释
第六个注释
"""
print("Hello World")
执行以上代码,输出结果为:
Hello World
标识符是程序中某一元素(变量、关键字、函数、类、模块、对象)的名字。说通俗点,标识符就是以后给我们写的每个代码所起的名字,就好比我们每个人生下来都要起名字。除了关键字的名字是固定的,其它元素都可以根据标识符的命名规则进行命名。
标识符由字母( A~Z , a~z )、数字(0-9)、以及下划线(_)组成。
(1)标识符的第一个字符必须是字母( A~Z , a~z )或下划线(_);
比如:
Hello
apple
_max
_Min
(2)标识符的其它部分由字母( A~Z , a~z )、数字(0-9)或者下划线(_)组成;
比如:
Apple10
Apple_10
V_3_V
CON2_5
_Test_3
(3)标识符对大小写敏感;
比如:
A 和 a
Apple 和 apple
Sum_ 和 sum_
_name 和 _NAME
Test2 和 test2
变量是标识符的一种,是一个用于保存值的占位符。可以通过变量名获得对值的引用,可以是任意的数据类型。变量命名时尽量体现出值的数据类型。如命名 count、length 和 size 表明数据类型是数字,命名 name、title 和 message 表明数据类型是字符串,单个字符命名的变量诸如 i、j、k 通常在循环中使用。
Python 中使用变量,不需要声明,直接为变量赋值即可使用,比如:
a = 10
print(a)
执行以上代码,输出结果为:
10
上述代码中,a 即为变量。但要注意,不能使用没有进行过赋值的变量,使用之后就会报错,比如:
print(a)
执行以上代码,输出结果为:
Traceback (most recent call last):
File "", line 1, in <module>
print(a)
NameError: name 'a' is not defined
有一分部标识符是 Python 自带的、具有特殊含义的名字,我们称之为“关键字”,或者“保留字”;关键字已经被 Python 使用,所以不允许开发者自己定义和关键字名字相同的标识符。
Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:【Win+R】调出【运行】弹窗>>>输入“cmd”>>>点击【确定】>>>在打开的界面中输入“python”>>>回车,进入 Python 交互模式,在交互模式下输入以下代码:
>>> import keyword
>>> keyword.kwlist
执行以上代码,输出结果为当前版本的所有关键字:
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
Python 输出主要包括标准化输出、格式化输出、不换行输出、换行输出和更换间隔字符输出。
Python 编程中 print 的用法是输入 print(),括弧中可以是数字、变量、字符串、列表、元组合字典。需要注意的是:① print 一定要全部小写;② print 后边的括弧要在英文状态输入。
(1)括号内可以是字符串,需要用单引号或双引号括起来,比如:
print("Hello World")
print('Hello World')
执行以上代码,输出结果为:
Hello World
Hello World
(2)括号内可以是数字或者数字的运算,比如:
print(7)
print(7+5)
执行以上代码,输出结果为:
7
12
(3)括弧内可以是变量或者变量的运算,比如:
a = 4
b = 7*8/2
print(a)
print(b)
print(a+b)
执行以上代码,输出结果为:
4
28.0
32.0
(3)括号内可以是字符串和数字的组合,需要把数字用引号括起来作为字符串使用,比如:
print("My lucky number is"" 6 ")
执行以上代码,输出结果为:
My lucky number is 6
(4)括号内可以是字符串和变量的组合,比如:
a = 3
print("输出的数字为:", a)
执行以上代码,输出结果为:
输出的数字为: 3
格式化是对字符串进行一定的格式显示或输出的方式,可以通过 % 和 format 函数实现。
% 符号可以实现字符串的格式化。在字符串内部 %() 表示特定格式字符串的占位,字符串右侧通过 % 连接要格式化的参数,它们和内部占位符 % 一一对应,中间不需要逗号连接。常用的格式符号如下:
i格式符号 | 转换 |
---|---|
%d | *有符号十进制整数 |
%s | *通过str()字符串转换来格式化 |
%i | 有符号十进制整数 |
%c | 字符 |
%u | 无符号十进制整数 |
%o | 八进制整数 |
%x | 十六进制整数(小写字母) |
%X | 十六进制整数(大写字母) |
%e | 索引符号(小写’e’) |
%E | 索引符号(大写"E") |
%f | 浮点实数 |
%g | %f和%e的简写 |
%G | %F和%E的简写 |
① %d 的使用,比如:
number = 6
print("My lucky number is %d" % number)
执行以上代码,输出结果为:
My lucky number is 6
② %s 的使用,比如:
print("My name is %s" % "Li Ming")
name = "Jenny"
print("Her name is %s" % name)
print("My name is %s"" and my lucky colour is %s" % ("Li Ming", "blue"))
执行以上代码,输出结果为:
My name is Li Ming
Her name is Jenny
My name is Li Ming and my lucky colour is blue
format 函数是字符串内嵌的一个方法,用于格式化字符串。以大括号 {} 来标明被替换的字符串,语法格式为:“{}”.format()
(1)通过大括号 {} 的默认顺序依次匹配元组中的参数
str = "{} is a beautiful {}!".format("Beijing","city")
print(str)
执行以上代码,输出结果为:
Beijing is a beautiful city!
(2)通过索引的方式匹配参数
str1 = "{0} is a beautiful {1}!".format("Beijing", "city")
print(str1)
str2 = "{1} is a beautiful {2}!".format("Tianjin","Beijing", "city")
print(str2)
执行以上代码,输出结果为:
Beijing is a beautiful city!
Beijing is a beautiful city!
(3)通过参数名匹配参数
str1 = "{name1} is a beautiful {name2}!".format(name1="Beijing", name2="City")
print(str1)
执行以上代码,输出结果为:
Beijing is a beautiful city!
(4)混合使用
① 可以通过索引,参数名混合进行匹配,但命名参数必须写到最后,否则会报错:
str1 = "{0} is a beautiful {name}!".format("Beijing", name="city")
print(str1)
执行以上代码,输出结果为:
Beijing is a beautiful city!
② 可以通过默认顺序和参数名混合进行匹配,但命名参数必须写到最后,否则会报错:
str1 = "{} is a beautiful {name}!".format("Beijing", name="city")
print(str1)
执行以上代码,输出结果为:
Beijing is a beautiful city!
③ 不可以索引和默认顺序混合使用,否则会报错。
(5)通过对象的属性匹配参数
class Names:
Name1 = "Beijing"
Name2 = "city"
str1 = "{names.Name1} is a beautiful {names.Name2}!".format(names=Names)
print(str1)
执行以上代码,输出结果为:
Beijing is a beautiful city!
(6)引用参数部分
str1 = "The first letter of '{word}' is '{word[0]}'.".format(word="hello")
print(str1)
执行以上代码,输出结果为:
The first letter of 'hello' is 'h'.
(7)数字的处理
① 保留小数位数
str1 = "π is {:.2f}.".format(3.1415926) #保留两位小数
print(str1)
执行以上代码,输出结果为:
π is 3.14.
② 给数字加千位符
str1 = "{:,}".format(100000000)
print(str1)
执行以上代码,输出结果为:
100,000,000
③ 进制的转换
s1 = "{:b}".format(8) # 将数字8转换为二进制
print(s1)
s2 = "{:o}".format(8) # 将数字8转换为八进制
print(s2)
s3 = "{:x}".format(12) # 将数字12转换为十六进制
print(s3)
执行以上代码,输出结果为:
1000
10
C
(8)格式的处理
通过 :数字 指定转换后的字符串长度,不足的部分用空格补充:
s = "{:2}b".format('a')
print(s)
# 如果指定的长度小于参数的长度,按照原参数匹配
s1 = "{:2}World".format('Hello')
print(s1)
执行以上代码,输出结果为:
a b
HelloWorld
(9)字符的填充
可通过 :符号^数字 进行字符串的填充,其中数字为填充后的字符串总长度:
s = "{:*^10}".format('Hello')
print(s)
s = "{:-^20}".format('123456')
print(s)
执行以上代码,输出结果为:
**Hello***
-------123456-------
(10)匹配列表、字典中的参数
在 format 函数格式化时,可使用 * 或者 ** 对列表、字典和元组进行拆分。
① 匹配列表中的参数
list = ["Beijing", "city"]
str1 = "{} is a beautiful {}!".format(*list)
str2 = "{1} is a beautiful {0}!".format(*list)
print(str1)
print(str2)
执行以上代码,输出结果为:
Beijing is a beautiful city!
city is a beautiful Beijing!
② 匹配字典中的参数
dict = {"name1": "Beijing", "name2": "city"}
str1 = "{name1} is a beautiful {name2}!".format(**dict)
print(str1)
执行以上代码,输出结果为:
Beijing is a beautiful city!
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=“”,比如:
print("a")
print("b", end="")
print("c")
执行以上代码,输出结果为:
a
bc
(1)print 默认输出是换行的,此外,在变量末尾加上 end=“\n” 可以在多个 print 函数的输出结果中实现换行,比如:
print("a")
print("b", end="")
print("c", end="\n")
print("d")
执行以上代码,输出结果为:
a
bc
d
(2)转义字符 \n 可以在 print 一次性输出的字符串中间换行,比如:
print("123456789---------")
print("123456789\n---------")
执行以上代码,输出结果为:
123456789---------
123456789
---------
(3)可以借助 for 循环和 while 循环实现换行输出,比如:
# for 循环实现换行输出
a = "hello"
for i in a:
print(i)
# while 循环实现换行输出
j = 0
while j <= 4:
print(a[j])
j += 1
执行以上代码,输出结果为:
h
e
l
l
o
h
e
l
l
o
(1)在变量末尾加上 end=“\t” 可以在多个 print 函数的输出结果中实现水平制表符,比如:
print("a", end="\t")
print(end="")
print("b")
执行以上代码,输出结果为:
a b
(2)转义字符 \t 可以在 print 一次性输出的字符串中间实现水平制表符,比如:
print("123456789\t---------")
执行以上代码,输出结果为:
123456789 ---------
默认情况下,print() 函数一次性输出的两个字符串使用空格分隔,在变量末尾加上参数 sep =“” 可以修改间隔字符,比如:
print("www", "baidu", "com")
print("www", "baidu", "com", sep=".")
print("www", "baidu", "com", sep="/")
执行以上代码,输出结果为:
wwwbaiducom
www.baidu.com
www/baidu/com
Python 中存在四种不同的数字(Number)类型,整数(int)、浮点数(float)、布尔类型(bool)和复数(complex)。
整数(int)是完整的数字,正数或负数,没有小数,长度不限。默认用十进制表示,同时也支持二进制,八进制,十六进制表示方式。比如:
3
-3
Python 的浮点数(float)也就是数学中的小数。比如:
3.14
2.5
-0.3
Python 中提供了 bool 类型来表示真(对)或假(错),并分别用 关键字 Ture(真或对)或 False(假或错)来表示,在 Python中,是明确区分大小写的,即首字母一定要大写,不然解释器会报错。比如:
print(True)
print(False)
执行以上代码,输出结果为:
True
False
bool 类型只有 Ture 和 False 两个实例,且 bool 值可以当作整数来代替,即 True 代表整数1,False 代表整数 0,并可以参与运算,但在项目开发中不能这样用:
print(5 > 4)
print(5 < 4)
print(True+1)
print(False+1)
执行以上代码,输出结果为:
True
False
2
1
复数由实数部分和虚数部分组成,可以用 a+bj 或者 complex(a, b)表示,复数的实部 a 和虚部 b 都是浮点型。
(1)方式一:a+bj
1+4j
-8j
(2)方式二:complex(a, b)
complex(1, 4)
complex(0, -8)
数据类型转换是将自身数据类型转化成新的数据类型,并拥有新数据类型相关操作的过程。
有时你可能想知道某个程序中的变量类型,也许这个类型从代码中并不明显,或者你从一个代码无法访问的源头得到了这个信息。每当你想查看一个变量的类型时,你可以使用 type() 函数,语法格式为 type(object),其中 object 为需要查看数据类型的目标数据,不需要用引号引起来。
(1)识别字符串(str),比如:
name1 = "Li Ming"
print(type(name1))
name2 = "123456"
print(type(name2))
执行以上代码,输出结果为:
<class 'str'>
<class 'str'>
用 type() 函数检查 “Li Ming” 显示它的类型是 str;用 type() 函数检查 “123456”,这个变量再次持有 str 的类型,尽管我们看到了数字,但它是一个被双引号引起来的数字字符串,而不是实际的数字类型。
(2)**识别整数(int),浮点数(float) ,布尔类型(bool)和复数(complex),**比如:
name1 = 123456
print(type(name1))
name2 = 1.23456
print(type(name2))
print(type(5 > 4))
print(type(4 > 5))
print(type(1+4j))
print(type(complex(4, 5)))
执行以上代码,输出结果为:
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'bool'>
<class 'complex'>
<class 'complex'>
在隐式类型转换中,Python 会自动将一种数据类型转换为另一种数据类型,不需要我们去干预,比如:
print(type(1+0.1))
执行以上代码,输出结果为:
<class 'float'>
我们对两种不同类型的数据进行运算,较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失。
在显式类型转换中,用户将对象的数据类型转换为所需的数据类型。
(1)int() 函数
int() 函数用于将一个字符串或数字转换为整型。语法格式为 int(x, base=10),x 为字符串或数字,base 为进制数,默认十进制。
① 不输入参数时,输出结果为 0:
print(int())
print(int(3))
print(int(3.6))
执行以上代码,输出结果为:
0
3
3
② 若 x 为纯数字,则不能有 base 参数,否则报错,比如:
print(int(3, 10))
执行以上代码,输出结果为:
Traceback (most recent call last):
File "", line 1, in <module>
print(int(3, 10))
TypeError: int() can't convert non-string with explicit base
如果是带参数 base 的话,x 要以字符串的形式进行输入,比如:
print(int("3", 10))
执行以上代码,输出结果为:
3
(2)float() 函数
float() 函数用于将整数和字符串转换成浮点数。语法格式为 float(x),其中 x 为整数或字符串。比如:
print(float(3)) # 整数
print(float(3.0)) # 小数
print(float(-3.0)) # 小数
print(float("3")) # 字符串
print(float("3.0")) # 字符串
执行以上代码,输出结果为:
3.0
3.0
-3.0
3.0
3.0
(3)str() 函数
**str() 函数用于将参数转换成字符串类型,即适于人阅读的形式。**比如:
print(str(1))
print(str("1"))
执行以上代码,输出结果为:
1
1
Python 中 input 函数用于提示并获取终端用户输入内容,一般获取的输入内容为字符串类型。 **input 函数的语法格式为 input(tips),其中 tips 为提示信息,一般用引号引起来提示输出。**运行代码之后可自定义输入目标数据,返回结果为字符串 str 类型。比如:
a = input("请输入账号:")
print("您输入的账号为:%s" % a)
print("您输入的账号类型为:", type(a))
执行以上代码,输出结果为:
请输入账号:abcdefg
您输入的账号为:abcdefg
您输入的账号类型为: <class 'str'>
Python 运算符主要包括算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符和身份运算符。
算术运算符包括:加(+)、减(-)、乘(*)、除(/)、取模(%)、幂(**)和取整除(//)。以下假设变量 a=10,变量 b=21:
运算符 | 含义 | 描述 | 实例 |
---|---|---|---|
+ | 加 | 两个对象相加 | a + b 输出结果 31 |
- | 减 | 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
* | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
/ | 除 | x 除以 y | b / a 输出结果 2.1 |
% | 取模 | 返回除法的余数 | b % a 输出结果 1 |
** | 幂 | 返回 x 的 y 次幂 | a ** b 为10的21次方 |
// | 取整除 | 往小的方向取整数 | b // a 输出结果 2 |
比较运算符包括:等于(==)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)和小于等于(<=)。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量 True 和 False 等价。以下假设变量 a 为10,变量 b 为20:
运算符 | 含义 | 描述 | 实例 |
---|---|---|---|
== | 等于 | 比较对象是否相等 | a == b 返回 False |
!= | 不等于 | 比较两个对象是否不相等 | a != b 返回 True |
> | 大于 | 返回 x 是否大于 y | a > b 返回 False |
< | 小于 | 返回 x 是否小于 y | a < b 返回 True |
>= | 大于等于 | 返回 x 是否大于等于 y | a >= b 返回 False |
<= | 小于等于 | 返回 x 是否小于等于 y | a <= b 返回 False |
赋值运算符包括:简单的赋值运算符(=)、加法赋值运算符(+=)、减法赋值运算符(-=)、乘法赋值运算符(*=)、除法赋值运算符(/=)、取模赋值运算符(%=)、幂赋值运算符(**=)和取整除赋值运算符(//=)。
运算符 | 含义 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c * a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
比如:
a = 2 b = 11 c = a + b print(c) c += a print(c) c -= a print(c) c *= a print(c) c /= a print(c) c %= a print(c) c **= a print(c) c //= a print(c)
执行以上代码,输出结果为:
13
15
13
26
13.0
1.0
1.0
0.0
按位运算符是把数字看作二进制来进行计算。
(1)位运算符的规则
程序中的数在计算机内存中都是以二进制的形式存在的,位运算就是直接对整数在内存中对应的二进制位进行操作。比如,a 为 60,b 为 13,它们的二进制格式如下:
a = 0011 1100
b = 0000 1101
运算符 | 含义 | 描述 | 实例 |
---|---|---|---|
& | 按位与运算符 | 参与运算的两个值,如果两个相应位都为 1,则该位的结果为 1,否则为 0 | (a & b) 输出结果 12 ,二进制解释:0000 1100 |
| | 按位或运算符 | 只要对应的二个二进位有一个为 1 时,结果位就为 1 | (a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ | 按位异或运算符 | 当两对应的二进位相异时,结果为 1 | (a ^ b) 输出结果 49 ,二进制解释:0011 0001 |
~ | 按位取反运算符 | 对数据的每个二进制位取反,即把 1 变为 0,把 0 变为 1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。 |
<< | 左移动运算符 | 运算数的各二进位全部左移若干位,由“<<”右边的数指定移动的位数,高位丢弃,低位补0 | a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> | 右移动运算符 | 把“>>”左边的运算数的各二进位全部右移若干位,“>>”右边的数指定移动的位数 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
(2)二进制与十进制之间的转换方法
① 十进制转二进制
Ⅰ 十进制正整数转换为二进制
采用"除2取余,逆序排列"法。具体做法是:用2去除十进制整数,可以得到一个商和余数;再用2去除商,又会得到一个商和余数,如此进行,直到商为0时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。比如:
十进制正整数 78 转换为二进制数 1001110
Ⅱ 十进制负整数转换为二进制整数
先是将对应的正整数转换成二进制后,对二进制取反,然后对结果再加 1。比如:
十进制负整数 -83 转换为二进制整数
Ⅲ 十进制小数转换为二进制
对小数点以后的数乘以 2,有一个结果吧,取结果的整数部分(不是 1 就是 0 喽),然后再用小数部分再乘以 2,再取结果的整数部分……以此类推,直到小数部分为 0 或者位数已经够了就 OK 了。然后把取的整数部分按先后次序排列就 OK 了,就构成了二进制小数部分的序列。比如:
十进制小数 0.125 转换为二进制
② 二进制转十进制
Ⅰ 二进制正整数转换为十进制
首先将二进制数补齐位数,首位如果是 0 就代表是正整数,如果首位是 1 则代表是负整数。
先看首位是 0 的正整数,补齐位数以后,将二进制中的位数分别将下边对应的值相乘,然后相加得到的就为十进制,比如 1010 转换为十进制:
二进制正整数 1010 转换为十进制
Ⅱ 二进制负整数转换为十进制
若二进制补足位数后首位为 1 时,就需要先取反再换算:比如,11101011,首位为 1,那么就先取反:-00010100,然后算一下 10100 对应的十进制为20,所以对应的十进制为-20:
二进制负整数 11101011 转换为十进制
Ⅲ 二进制小数转换为十进制
例如 0.1101 转换为十进制的方法:将二进制中的四位数分别于下边对应的值相乘后相加得到的值即为换算后的十进制。
二进制小数 0.1101 转换为十进制
(3)补码与源码
**现在计算机普遍使用补码表示负数,但是如果任意给出一个二进制数字,无法分辨它是源码还是补码。如果确认是补码,求源码的方式是:补码取反再加 1。**补码的第一位符号位决定了源码的正负,第一位为 0 源码为正,第一位为 1 源码为负。
比如,在求解 ~60 时,60 按位取反后得到 1100 0011,其第一位为1,源码为负值,取反后为 0011 1100,再加 1 得 0011 1101,其值为 61,再加上负号即为 -61。
(4)位运算符在 Python 中的应用
在进行十进制位运算时,无需转换为二进制,只要使用位运算符,Python 就会按照二进制来进行计算。比如:
a = 60
b = 13
print(a & b)
print(a | b)
print(a ^ b)
print(~a)
print(a << 2)
print(a >> 2)
执行以上代码,输出结果为:
12
61
49
-61
240
15
Python 语言支持逻辑运算符:
运算符 | 含义 | 逻辑表达式 | 描述 |
---|---|---|---|
and | 布尔“与” | x and y | 同真为真,一假则假 |
or | 布尔“或” | x or y | 同假才假,一真即真 |
not | 布尔“非” | x not y | 非真即假,非假即真 |
在 Python 中,整数0代表假,整数 1 代表真。除此之外,Python 也把任意的空数据结构视为假,把任何非空数据结构视为真。真和假的概念是 Python 中每个对象的固有属性,一般来说:**① 数字如果非零,则为真;② 其他对象如果非空,则为真。**Python 还有一个特殊对象:None,它总被认为是假。
比如:
a = 10 b = 20 if a and b: print("1 - 变量 a 和 b 都为 true") else: print("1 - 变量 a 和 b 有一个不为 true") if a or b: print("2 - 变量 a 和 b 都为 true,或其中一个变量为 true") else: print("2 - 变量 a 和 b 都不为 true") # 修改变量 a 的值 a = 0 if a and b: print("3 - 变量 a 和 b 都为 true") else: print("3 - 变量 a 和 b 有一个不为 true") if a or b: print("4 - 变量 a 和 b 都为 true,或其中一个变量为 true") else: print("4 - 变量 a 和 b 都不为 true") if not (a and b): print("5 - 变量 a 和 b 都为 false,或其中一个变量为 false") else: print("5 - 变量 a 和 b 都为 true")
执行以上代码,输出结果为:
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true,或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true,或其中一个变量为 true
5 - 变量 a 和 b 都为 false,或其中一个变量为 false
Python 支持成员运算符:
运算符 | 描述 |
---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False |
比如:
a = 1
b = 2
list = [2, 3, 4, 5]
if a in list:
print("a在列表中")
else:
print("a不在列表中")
if b not in list:
print("b不在列表中")
else:
print("b在列表中")
执行以上代码,输出结果为:
a不在列表中
b在列表中
(1)身份运算符是 Python 用来判断的两个对象的存储单元是否相同的一种运算符号,身份运算符只有 is 和 is not 两个运算符,返回的结果都是 True 或者 False:
运算符 | 描述 | 实例 |
---|---|---|
is | 判断两个标识符是不是引用自一个对象 | x is y, 如果引用的是同一个对象则返回 True,否则返回 False |
is not | 是判断两个标识符是不是引用自不同对象 | x is not y,如果引用的不是同一个对象则返回结果 True,否则返回 False |
比如:
a = 1
b = 2
c = a
print(a is b)
print(a is c)
print(a is not b)
print(a is not c)
执行以上代码,输出结果为:
False
True
True
False
再比如:
a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a)
print(b)
print(a is b)
print(a is c)
执行以上代码,输出结果为:
[0, 1, 2]
[0, 1, 2]
False
True
通过这个结果我们发现,a 和 b 引用的对象是不一致的,所以 a is b 输出的结果是 False,因为变量 b 是需要计算的,虽然计算之后得到的列表跟 a 一模一样,但是计算之前的过程每个元素是要存储的,变量 a 当中的元素都是数字,计算机是直接存储结果的,而变量 b 当中的每个元素都是表达式,表达式的储存跟单个元素的储存是不一致的,列表、元组都是如此。
(2)is 与 == 的区别
is 用于判断两个变量引用对象是否为同一个,== 用于判断引用变量的值是否相等。比如:
a = [0, 1, 2]
b = [1-1, 2-1, 3-1]
c = a
print(a is b)
print(a is c)
print(b is c)
print(a is b is c)
print(a == b == c)
执行以上代码,输出结果为:
False
True
False
False
True
以下表格列出了从最高到最低优先级的所有运算符, 相同单元格内的运算符具有相同优先级:
优先级 | 运算符 | 描述 | 结合性 |
---|---|---|---|
19 | () | 小括号 | 无 |
18 | x[i] | 索引运算符 | 左 |
17 | x.attribute | 属性访问 | 左 |
16 | ** | 乘方(指数) | 右 |
15 | ~ | 按位取反 | 右 |
14 | +, - | 正号,负号 | 右 |
13 | *, /, %, // | 乘,除,取模,取整除 | 左 |
12 | +, - | 加号,减号 | 左 |
11 | >>, << | 右移动运算符,左移动运算符 | 左 |
10 | & | 按位与运算符 | 右 |
9 | ^ | 按位异或运算符 | 左 |
8 | | | 按位或运算符 | 左 |
7 | ==, !=, <=, <, >, >= | 等于,不等于,小于等于,小于,大于等于,大于 | 左 |
6 | is, is not | 身份运算符 | 左 |
5 | in, not in | 成员运算符 | 左 |
4 | not | 逻辑运算符非 | 右 |
3 | and | 逻辑运算符与 | 左 |
2 | or | 逻辑运算符或 | 左 |
1 | exp1, exp2 | 逗号运算符 | 左 |
所谓结合性,就是当一个表达式中出现多个优先级相同的运算符时,先执行哪个运算符:先执行左边的叫左结合性,先执行右边的叫右结合性。例如对于表达式对于 100 / 25 * 16,/ 和 * 的优先级相同,应该先执行哪一个呢?这个时候就不能只依赖运算符优先级决定了,还要参考运算符的结合性。/ 和 * 都具有左结合性,因此先执行左边的除法,再执行右边的乘法,最终结果是 64。
Python 中大部分运算符都具有左结合性,也就是从左到右执行;只有 ** 乘方运算符、单目运算符(例如 not 逻辑非运算符)、赋值运算符和三目运算符例外,它们具有右结合性,也就是从右向左执行。
Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的,但是**同一个代码块的语句必须包含相同的缩进空格数,一般用 Tab 健进行操作。**比如:
if True:
print("Answer")
print("True")
else:
print("Answer")
print("False")
执行以上代码,输出结果为:
Answer
True
以下代码最后一行语句和同一代码块语句缩进数的空格数不一致,会导致运行错误:
if True:
print("Answer")
print("True")
else:
print("Answer")
print("False") # 缩进不一致,会导致运行错误
执行以上代码,输出结果为:
File ".py", line 6
print ("False")
^
IndentationError: unindent does not match any outer indentation level
条件判断是通过一条或多条判断语句的执行结果(True 或者 False)来决定执行的代码块。在 Python 语法中,使用 if、elif 和 else 三个关键字来进行条件判断,Python 中 if 语句的一般形式如下:
if 条件表达式_1:
代码块_1
elif 条件表达式_2:
代码块_2
else:
代码块_3
(1)如果 “条件表达式_1” 为 True,将执行 “代码块_1” 块语句
(2)如果 “条件表达式_1” 为 False,将判断 “条件表达式_2”
(3)如果"条件表达式_2" 为 True 将执行 “代码块_2” 块语句
(4)如果 “条件表达式_2” 为 False,将执行"代码块_3"块语句
注意:
① Python 中用 elif 代替了 else if,所以条件判断语句的关键字为:if – elif – else;
④ elif 后面加条件和冒号,而 else 后只能直接加冒号,不能加条件;可以有多个 elif ,但只能有一个 else。
③ 每个条件后面要使用冒号:,表示接下来是满足条件后要执行的语句块;
④ 使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块;
作业:(90, 100]-A, (80, 90]-B, (70, 80]-C, (60, 70]-D, [0, 60]-E,判断 score = 77 的等级。
score = 77
if 90 < score <= 100:
print("本次考试等级为 A")
elif 80 < score <= 90:
print("本次考试等级为 B")
elif 70 < score <= 80:
print("本次考试等级为 C")
elif 60 < score <= 70:
print("本次考试等级为 D")
else: # 这一行也可以写成:elif 0 <= score <= 60:
print("本次考试等级为 E")
执行以上代码,输出结果为:
本次考试等级为 C
if 嵌套
在嵌套 if 语句中,可以把 if - elif - else 结构放在另外一个 if - elif - else 结构中,但是要注意同一个代码块的语句必须包含相同的缩进空格数:
if 条件表达式_1:
代码块_1
if 条件表达式_2:
代码块_2
elif 条件表达式_3:
代码块_3
else:
代码块_4
elif 条件表达式_4:
代码块_5
else:
代码块_6
作业 :车辆驾驶员的血液酒精含量小于 20mg/100ml 不构成酒驾;酒精含量大于或等于 20mg/100ml 为酒驾;酒精含量大于或等于 80mg/100ml 为醉驾,请编写 Python 程序判断是否为酒后驾车。
content = int(input("请输入驾驶员每100ml血液酒精的含量:"))
if 0 <= content < 20:
print("驾驶员不构成酒驾")
elif 20 <= content < 100:
if 20 <= content < 80:
print("驾驶员构成酒驾但不构成醉驾")
elif 80 <= content < 100:
print("驾驶员构成醉驾")
assert 语句,又称断言语句,可以看做是功能缩小版的 if 语句,它用于判断某个表达式的值,如果值为真,则程序可以继续往下执行;反之,Python 解释器会报 AssertionError 错误。assert 语句通常用于检查用户的输入是否符合规定,还经常用作程序初期测试和调试过程中的辅助工具,可以有效预防 bug 的发生,提高程序的健壮性,语法格式为:
assert 条件表达式
代码块
注意:①“条件表达式”后不用加冒号 : ②“代码块”前不用缩进。
a = int(input("请输入考试分数:"))
assert 0 <= a <= 100 # 断言数学考试分数是否位于正常范围内
print("你的考试成绩为:", a) # 只有当考试成绩位于 [0,100]范围内,程序才会继续执行
执行以上代码,输出结果为:
# 输入96
请输入考试分数:96
你的考试成绩为: 96
# 输入101
请输入考试分数:101
AssertionError
Python 支持设置 AssertionError 的提示语句,语法格式为:assert + 空格 + 要判断语句, “报错语句”
① 当 assert 后条件表达式为假时:
a = 10
b = 1
assert a < b, "判断为假,因为 a < b"
执行以上代码,输出结果为:
Traceback (most recent call last):
File "C:\****", line 3, in <module>
assert a < b, "判断为假,因为 a < b"
^^^^^
AssertionError: 判断为假,因为 a < b
② 当 assert 后条件表达式为真时:
a = 10
b = 1
assert a > b, "a < b"
执行以上代码,没有报错。
(1)模块的导入
在 Python 中用 import 或者 from…import 来导入相应的模块:
比如:
import random # 引入随机数
x = random.randint(0, 2) # 随机生成 0、1、2 中的一个数字,赋值给变量 x
print(x)
(2)函数的调用
从某个模块导入某个函数后,调用该函数的语法格式为:模块名称.函数名称(变量)
比如,Python 中的 randint 用来生成指定范围内的随机整数,在使用 randint 之前,需要调用 random 库。该函数的语法格式为 random.randint(x, y),参数 x 和 y 代表生成随机数的区间范围,生成的随机数包括 x 和 y。
作业:综合使用 import 函数和 if 语句实现剪刀石头布游戏效果,剪刀(0),石头(1)、布(2)。
import random x = random.randint(0, 2) y = int(input("请输入剪刀、石头、布相对应的数字,其中剪刀(0),石头(1)、布(2):")) if y not in [0, 2]: print("你输入了 0、1、2 之外的数字,请重新输入!") exit() if y == 0: print("你出的是剪刀;") elif y == 1: print("你出的是石头;") elif y == 2: print("你出的是布;") if x == 0: print("电脑出的是剪刀;") elif x == 1: print("电脑出的是石头;") elif x == 2: print("电脑出的是布;") if x == y: print("你和电脑打平了。") else: if x == 0 and y == 1: print("恭喜,你赢了!") elif x == 0 and y == 2: print("很遗憾,你输了。") elif x == 1 and y == 0: print("很遗憾,你输了。") elif x == 1 and y == 2: print("恭喜,你赢了!") elif x == 2 and y == 0: print("恭喜,你赢了!") elif x == 2 and y == 1: print("很遗憾,你输了。")
(3)模块(包)的下载
在 Python 中,模块(包)是一组函数、类、变量或语句的集合,可以被其他程序引用。Python 拥有丰富的模块库,但是在使用时有时需要下载其他的模块。
①使用 pip 下载模块(包)
pip 是 Python 的包管理工具,可以用于安装、升级和卸载 Python 包。使用 pip 下载模块非常简单:右键开始菜单栏、选择“运行”、输入“cmd”并点击“确定”、在命令提示行中输入以下命令并回车:
pip install name
或者
pip install name==版本号
其中,name 表示模块(包)的名称;比如下载 pandas 模块:
pip install pandas
或者
pip install pandas==1.0.3
②使用 PyCharm 下载模块(包)
③在 PyCharm 代码编辑区下载模块(包)
点击底部标红的需要下载的模块名称,在弹出的对话框中继续点击“Install package 包名”,即可进行模块的安装。
在 PyCharm 代码编辑区下载模块(包)
只要是被引号【单、双、三引号】包裹起来的内容就叫字符串。这个内容可以是中文、英文、数字、图例等,只要在引号里就叫字符串。字符串英文为 string,简写为 str。
(1)单引号 ’ 和双引号 "
二者使用完全相同,用来指定一个单行字符串。
print('hello')
print("hello")
执行以上代码,输出结果为:
hello
hello
(2)三引号 ‘’’ 或 “”"
可以指定一个多行字符串:
print('''Hello
World
!''')
print("""Hello
World
!""")
执行以上代码,输出结果为:
Hello
World
!
Hello
World
!
(3)对引号进行转义
假设你想要在一个字符串中包含一个单引号(‘),肯定不能用 ‘What’ s your name ?’ 来指示它,因为 Python 会弄不明白这个字符串从何处开始,何处结束,所以,需要指明单引号而不是字符串的结尾。对于类似情况,有两种处理方案:
① 在引号前面添加反斜杠 \ 就可以对引号进行转义,让 Python 把它作为普通文本对待
print('What\'s your name ?')
print("Do you know \"Python\" ?")
执行以上代码,输出结果为:
What's your name ?
Do you know "Python" ?
② 使用不同的引号包围字符串
print("What\'s your name ?")
print('Do you know \"Python\" ?')
执行以上代码,输出结果为:
What's your name ?
Do you know "Python" ?
由反斜杠加上一个字符或数字组成,它把反斜杠后面的字符或数字转换成特定的意义。简单来说就是字符要转成其他含义的的功能,所以我们叫它 “转义字符”。转义字符的意义就是避免出现二义性,避免系统识别错误。
符号 | 名称 | 描述 |
---|---|---|
\(在行尾时) | 续行符 | 在使用时要注意,可以在 \ 前有空格等,但是 \ 后面不要有空格,后面一定要紧跟着回车换行,否则就会报错 |
\ | 反斜杠符号 | 转义反斜杠 |
’ | 单引号 | 转义字符串中的单引号 |
" | 双引号 | 转义字符串中的双引号 |
\n | 换行 | 一般用于末尾 |
\t | 横向制表符 | 可以认为是一个间隔符 |
\r | 回车 | 表示将光标的位置回退到本行的开头位置 |
\b | 退格 | 将光标前移,覆盖删除前一个 |
a = 1 + 2 + 3 + 4 + 5 + 6 \
+ 7 + 8 + 9 + 10 + 11 \
+ 12 + 13 + 14 + 15 + 16 # 反斜杠实现续行
print(a)
print("\\a") # 反斜杠转义反斜杠
print("Do you know \"Python\" ?") # 反斜杠转义双引号
print('Do you know \'Python\' ?') # 反斜杠转义单引号
print("What's your name ?\nHow old are you ?") # 反斜杠实现换行
print("aa\taa") # 反斜杠实现横向制表符
print("aaaa\rb") # 反斜杠实现删除反斜杠之前所有元素
print("aaa\bb") # 反斜杠实现退格
执行以上代码,输出结果为:
136
\a
Do you know "Python" ?
Do you know 'Python' ?
What's your name ?
How old are you ?
aa aa
b
aab
使用 r 或者 R 可以让反斜杠不发生转义:
print(r"\\a")
print(r"Do you know \"Python\" ?")
print(r'Do you know \'Python\' ?')
print(r"What's your name ?\nHow old are you ?")
print(r"aa\taa")
print(r"aaaa\rb")
print(r"aaa\bb")
执行以上代码,输出结果为:
\\a
Do you know \"Python\" ?
Do you know \'Python\' ?
What's your name ?\nHow old are you ?
aa\taa
aaaa\rb
aaa\bb
Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
字符串的索引
(1)检索字符串中是否包含目标字符串
find 函数用于查找字符串中是否包含目标字符串,指定 start 和 end 的范围(顾头不顾尾),检查目标字符串是否包含在指定范围内,如果指定范围内包含目标字符串,返回的是**目标字符串中的起始位置对应的索引值;**如果不包含目标函数,返回-1,语法格式为:str.find(sub, start, end)
同 find 函数类似,index 函数也可以用于检索是否包含指定的字符串,不同之处在于,当指定的字符串不存在时,index 函数会抛出异常,语法格式为:str.index(sub, start, end)
str = "abcdefghijklmn"
print(str.find("abc"))
print(str.find("lmn"))
print(str.find("n", 5, 13))
print(str.index("abc"))
print(str.index("n", 5, 13))
执行以上代码,输出结果为:
Traceback (most recent call last):
File ".py", line 6, in <module>
print(str.index("n", 5, 13))
^^^^^^^^^^^^^^^^^^^^^
ValueError: substring not found
0
11
-1
0
(2)检索字符串包含目标字符串的次数
count 函数用于查找目标字符串在另一字符串中出现的次数,指定 start 和 end 的范围(顾头不顾尾),如果检索的字符串不存在,则返回 0,否则返回出现的次数,语法格式为:str.count(sub, start, end)
str = "abcabcabcabc"
print(str.count("abc", 0, 3))
print(str.count("a"))
执行以上代码,输出结果为:
1
4
replace 函数可以将指定字符串替代为目标字符串,语法格式为:str.replace(old_str, new_str, num)
① 其中 str 为定义的字符串;② old_str 为需要被替换的字符串;③ new_str 为替换的新字符串;④ num 为可选参数, 若不添加可选参数 num,默认将所有的多个被替换的字符串 old_str 全部替换为新字符串new_str,若添加可选参数 num,则将字符串 str 中的前不超过 num 个的字符串 old_str 替换为字符串 new_str。
str1 = "Welcome to Beijing ! Beijing is a beautiful city ."
print(str1.replace("Beijing", "Wuhan"))
str2 = "Welcome to Beijing ! Beijing is a beautiful city . I love Beijing . Do you love Beijing ?"
print(str2.replace("Beijing", "Wuhan", 2))
执行以上代码,输出结果为:
Welcome to Wuhan ! Wuhan is a beautiful city .
Welcome to Wuhan ! Wuhan is a beautiful city . I love Beijing . Do you love Beijing ?
(1)strip 函数
strip 函数用于删除字符串头、尾指定的字符(默认为空格)或字符序列,但只能删除开头或是结尾的字符,不能删除中间部分的字符,语法格式为:str.strip([chars])
其中,str 表示原字符串,[chars] 用来指定要删除的字符,可以同时指定多个,如果未指定参数,即 str.strip(),则默认会删除空格以及制表符、回车符、换行符等特殊字符;带有参数的时候,删除多个字符时只要原字符串的头、尾有对应其中的某个字符即删除,不考虑顺序,直到遇到第一个不包含在其中的字符为止。
str1 = " 123123123\n\t\r"
print(str1.strip())
str2 = "******123******"
print(str2.strip("*"))
str3 = "123321213231***123321132231"
print(str3.strip("123"))
print(str3.strip("132"))
print(str3.strip("213"))
str4 = "123321213231**123**123321132231"
print(str4.strip("213"))
str5 = "123321213231**123**123321132231"
print(str3.strip("123456789"))
执行以上代码,输出结果为:
123
***
***
***
**123**
**123**
(2)lstrip 函数
lstrip 函数用于删除字符串左侧指定的字符(默认为空格)或字符序列,语法格式为:str.lstrip([chars])
其中,str 表示原字符串,[chars] 用来指定要删除的字符,可以同时指定多个,如果未指定参数,即 str.lstrip(),则默认会从左到右开始删除空格以及制表符、回车符、换行符等特殊字符,直至不含这些特殊字符为止;带有参数的时候,从左到右删除多个字符时只要原字符串的左侧有对应其中的某个字符即删除,不考虑顺序,直到遇到第一个不包含在其中的字符为止。
str1 = " \n\t\r123123123\n123\r123\t123"
print(str1.lstrip())
str2 = "123123123***123***123123123"
print(str2.lstrip("123"))
str3 = "123123123***123***123123123"
print(str3.lstrip("123456"))
执行以上代码,输出结果为:
123123123
123 123
***123***123123123
***123***123123123
(3)rstrip 函数
rstrip 函数用于删除字符串右侧指定的字符(默认为空格)或字符序列,语法格式为:str.rstrip([chars])
其中,str 表示原字符串,[chars] 用来指定要删除的字符,可以同时指定多个,如果未指定参数,即 str.rstrip(),则默认会从右到左开始删除空格以及制表符、回车符、换行符等特殊字符,直至不含这些特殊字符为止;带有参数的时候,从右到左删除多个字符时只要原字符串的右侧有对应其中的某个字符即删除,不考虑顺序,直到遇到第一个不包含在其中的字符为止。
str1 = "123\n123\t123\r123123123\n\r\t "
print(str1.rstrip())
str2 = "123123123***123***123123123"
print(str2.rstrip("123"))
str3 = "123123123***123***123123123"
print(str3.rstrip("123456"))
执行以上代码,输出结果为:
123
123123123
123123123***123***
1203123123***123***
len 函数用来返回一个对象实例(字符、列表、元组等)的长度或项目个数,语法格式为:len(str),其中 str 用于指定要进行长度统计的字符串:
str1 = "Beijing!"
str2 = "北京欢迎你!"
print(len(str1))
print(len(str2))
print(len("Beijing!"))
print(len("北京欢迎你!"))
执行以上代码,输出结果为:
8
6
8
6
在 Python 中,不同的字符所占的字节数不同,数字、英文字母、小数点、下划线以及空格,各占一个字节,而一个汉字可能占 2~4 个字节,具体占多少个,取决于采用的编码方式。例如,汉字在 GBK/GB2312 编码中占用 2 个字节,而在 UTF-8 编码中一般占用 3 个字节。我们可以使用 encode 函数,将字符串进行编码后再获取它的字节数,语法格式为:**len(str.encode(“编码格式”)),**其中 str 用于指定要进行长度统计的字符串,编码格式包括 GBK 等,不填默认为 UTF-8。
str1 = "人生苦短,我用Python"
print(len(str1.encode()))
print(len(str1.encode("gbk")))
执行以上代码,输出结果为:
27
20
Python提供了 3 种可用来进行字符串对齐的方法,分别是 ljust 函数、rjust 函数 和 center 函数。
(1)ljust 函数
ljust 函数返回一个原字符串左对齐,并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串,语法格式为:str.ljust(width[, fillchar])
str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.ljust(30))
print(str2.ljust(30))
print(str1.ljust(10))
print(str2.ljust(10))
print(str1.ljust(30, "*"))
print(str2.ljust(30, "*"))
执行以上代码,输出结果为:
https://github.com/ # 该输出结果中除了明显可见的网址字符串外,其后还有空格字符存在,每行一共 30 个字符长度
https://www.bilibili.com/ # 该输出结果中除了明显可见的网址字符串外,其后还有空格字符存在,每行一共 30 个字符长度
https://github.com/
https://www.bilibili.com/
https://github.com/***********
https://www.bilibili.com/*****
(2)rjust 函数
rjust 函数返回一个原字符串右对齐,并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串,语法格式为:str.rjust(width[, fillchar])
str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.rjust(30))
print(str2.rjust(30))
print(str1.rjust(10))
print(str2.rjust(10))
print(str1.rjust(30, "*"))
print(str2.rjust(30, "*"))
执行以上代码,输出结果为:
https://github.com/
https://www.bilibili.com/
https://github.com/
https://www.bilibili.com/
***********https://github.com/
*****https://www.bilibili.com/
(3)center 函数
center 函数返回一个原字符居中对齐,并使用指定字符填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串,语法格式为:str.center(width[, fillchar])
str1 = "https://github.com/"
str2 = "https://www.bilibili.com/"
print(str1.center(30))
print(str2.center(30))
print(str1.center(10))
print(str2.center(10))
print(str1.center(30, "*"))
print(str2.center(30, "*"))
执行以上代码,输出结果为:
https://github.com/
https://www.bilibili.com/
https://github.com/
https://www.bilibili.com/
*****https://github.com/******
**https://www.bilibili.com/***
(1)字符串的截取
字符串的截取的语法格式为:**str[start声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:【wpsshop博客】
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。