Python Day02
Python Day02
Python 循环控制
for循环
for语句是python中的循环控制语句。可用来遍历某一对象，还具有一个附带的可选的else块，主要用于处理for语句中包含的break语句。
for语句的格式如下：
>>>for <> in <对象集合>： ... if <条件>: ... break ... if <条件>: ... continue ... <其他语句> ...else: ... <> ...
#循环打印10个数（0-9），基本的循环
for n in range(10): print(n)
执行结果：
C:\Users\wangzhigang\AppData\Local\Programs\Python\Python35-32\python.exe C:/Users/wangzhigang/PycharmProjects/untitled/Python/Day02/1017.py 0 1 2 3 4 5 6 7 8 9 Process finished with exit code 0
#加上else模块
for n in range(100): if n < 20: print(n) continue else: print("Hello")
如果for循环未被break终止，则执行else块中的语句。
break 在需要时终止for循环
continue 跳过位于其后的语句，开始下一轮循环。
注：range()函数。
range([start,] stop [, step])
* start 可选参数，起始数
* stop 终止数，如果 range 只有一个参数x，则产生一个包含 0 至 x-1 的整数列表
* step 可选参数，步长
while循环
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
while 判断条件： 执行语句……
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
当判断条件假false时，循环结束。
执行流程图如下：
实例：
count = 0 while count < 9: print("this count is ",count) count += 1 print("This is end!")
执行结果：
this count is 0 this count is 1 this count is 2 this count is 3 this count is 4 this count is 5 this count is 6 this count is 7 this count is 8 This is end!
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：
continue用法：
count = 1 while count < 10: count += 1 if count%2 > 0: #非双数时跳出循环 continue print(count) #打印双数
输出结果：
2 4 6 8 10
break用法：
count = 1 while 1: print(count) count += 1 if count > 10: #当count大于10的时候跳出本循环 print("This is END!")
break
输出结果：
1 2 3 4 5 6 7 8 9 10 This is END!
数据类型
Python中的数据类型
Python中的变量不需要声明。每个变量在使用前必须要赋值，变量赋值以后才会被创建。在Python中，变量就变量，是没有类型的。
所说的“类型”是变量所指的内存中对象的类型。Python使用对象模型来存储数据，每一个数据类型都有一个内置的类，每新建一个数据，实际就是在初始化生成一个对象，所有数据都是对象。
对象三个特性
- 身份：内存地址，可以用id()获取
- 类型：决定了该对象可以保存什么类型值，可执行何种操作，需遵循什么规则，可用type()获取
- 值：对象保存的真实数据
Python中的标准数据类型：
* Numbers （数字）
* String （字符串）
* List （列表）
* Tuple （元组）
* Dic （字典）
（1） 数字
数字类型的分类：
* int （整型）
* long （长整型）
* bool （布尔）
* complex （复数）
* float （浮点数）
int 整型
Python中的整型可以用十进制、八进制和十六进制表示。
>>> 10 10 >>> oct(10) '0o12' >>> hex(10) '0xa' >>> type 10
<class 'int'> >>> type(0xa) <class 'int'> >>> type(0o12) <class 'int'>
long 长整型
python2.*：
跟C语言不同，Python的长整型没有指定位宽，也就是说Python没有限制长整型数值的大小，
但是实际上由于机器内存有限，所以我们使用的长整型数值不可能无限大。
在使用过程中，我们如何区分长整型和整型数值呢？
通常的做法是在数字尾部加上一个大写字母L或小写字母l以表示该整数是长整型的，例如：
a = 9223372036854775808L
注意，自从Python2起，如果发生溢出，Python会自动将整型数据转换为长整型，
所以如今在长整型数据后面不加字母L也不会导致严重后果了。
python3.*
长整型，整型统一归为整型
bool 布尔
True 和 False 就是1和0
complex 复数
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注意，虚数部分的字母j大小写都可以，
浮点数
Python中的浮点数就是数学中的小数，类似C语言中的double，
在运算中，整数与浮点数运算的结果是浮点数。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差。
数字相关内建函数
字符串
字符串的常用操作
* 移除空白
* 分割
* 长度
* 索引
* 切片
字符串函数：
captalize ==>字符串中的第一个字母大写
names = "hello world" print(names.capitalize()) #capitalize 字符串第一个字母大写
#执行结果：
Hello world
casefold ==> 将字符串中的大写字母转换为小写
names = "HELLO WORLD" print(names.casefold()) #casefold 将字符串中的大写字母转换为小写
#执行结果
hello world
center ==>将字符串居中；可以设置左右填充的内容
names = "Hello World" print(names.center(25,'*')) #center 将字符串居中；可以设置左右填充的内容
#执行结果：
*******Hello World*******
count ==>统计字符串中某个元素的个数；可以设置开始结束区间
names = "Hello World" print(names.count('l')) #count 统计字符串中某个元素的个数；可以设置开始结束区间
#执行结果：
3
endswith ==> 字符串中以指定元素结尾，如果为真，则返回True，否则返回False；可以设置开始结束区间
names = "Hello World" print(names.endswith('d')) #endswith 字符串中以指定元素结尾，如果为真，则返回True，否则返回False；可以设置开始结束区间
#执行结果：
True
expandtabs ==>设置字符串中tab（\t）的空格数，默认为8个空格
new_names = "hello\tworld" print(new_names.expandtabs(15)) #expandtabs 设置字符串中tab（\t）的空格数，默认为8个空格；
#执行结果：
hello world
find ==>查找字符串中的元素，如果有这个元素，返回的是元素所在的下标；如果不存在，则返回-1；可以设置开始结束区间；
names = "Hello World" print(names.find('d')) #查找字符串中的元素，如果有这个元素，返回的是元素所在的下标；如果不存在，则返回-1；可以设置开始结束区间
#执行结果：
10
format ==>格式化字符串
#format的三种形式： #第一种： print('{0}{1}{0}'.format('a','b','e')) aba #第二种： print('{}{}{}'.format('a','b','c','d')) #必须是一一对应的； abc #第三种： print('{name} {age} '.format(age=25,name="wangzhigang")) wangzhigang 25
index ==>查找某个元素的索引下标，如果元素存在，则返回对应的下标；如果不存在，则报错
names = "Hello World" print(names.index('o')) #查找某个元素的索引下标，如果元素存在，则返回对应的下标；如果不存在，则报错； #执行结果： 4 #如果不存在报错： Traceback (most recent call last): File "C:/Users/wangzhigang/PycharmProjects/untitled/Python/Day02/1018.py", line 59, in <module> print(names.index('x')) ValueError: substring not found
isalnum ==>检查判断字符串是否包含字母数字字符；
new_names = "hello" print(new_names.isalnum())
#isalnum 检查判断字符串是否包含字母数字字符;如果所有字符字母数字和至少有一个字符此方法返回 true，否则返回False
#执行结果： True
##### new_names = "hello 123"
print(new_names.isalnum())
#执行结果： False
isalpha ==>判断字符串中是否全部为字母，如果是则返回True，否则返回False；
new_names = "Helloworld" print(new_names.isalpha()) #isalpha 判断字符串中是否全部为字母，如果是则返回True，否则返回False #执行结果： True new_names = "Hello123" print(new_names.isalpha()) #执行结果： False
isdigit ==> 判断字符串是否为数字
names_new = "123" print(names_new.isdigit()) #isdigit 判断字符串是否为数字 #执行结果： True ######## names_new = "Hello" print(names_new.isdigit()) #isdigit 判断字符串是否为数字 #执行结果 False
islower ==>判断字符串是否为小写字母
names_new = "hello" print(names_new.islower()) #islower 判断字符串是否为小写字母 #执行结果： True names_new = "Hello" print(names_new.islower()) #执行结果 False
isnumeric ==> 判断字符串是否全部为数字
names_new = "123" print(names_new.isnumeric()) #isnumeric 判断字符串是否全部为数字 #执行结果： True names_new = "123hello" print(names_new.isnumeric()) #执行结果 False
istitle ==> 检查字符串中的所有单词拼写首字母是否为大写，且其他字母为小写
names_new = "Hello World " print(names_new.istitle()) #istitle 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。 #执行结果： True
names_new = "Hello world " print(names_new.istitle()) #执行结果 False
isupper ==>检查字符串中的字母是否为大写，如果是，则返回True；否则返回False；
names_new = "HELLO1111" print(names_new.isupper()) #isupper 检查字符串中的字母是否为大写，如果是，则返回True，否则返回False #执行结果： True ########## names_new = "Hello1111" print(names_new.isupper()) #执行结果 False
join ==>将序列中的元素以指定的字符连接生成一个新的字符串；
names1 = "_" names2 = ("wang","zhi","gang") print(names1.join(names2)) #join 将序列中的元素以指定的字符连接生成一个新的字符串 #执行结果 wang_zhi_gang
ljust ==> 返回一个字符串左对齐，并默认使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串，则返回原字符串。
names_new = "Hello" print(names_new.ljust(10,'#')) #ljust 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。 (25,'#') 25，表示字符串的总长度 '#'表示填充的字符,填充的内容可以是特殊字符，可以是数字，可以是字母，但是不可以是多个字母。例如'wa'； #执行结果： Hello#####
lower ==>将字符串中的大写字母转换为小写字母；
names_new = "HEllO" print(names_new.lower()) #lower 将字符串中的大写字母转换为小写 #执行结果： hello
lstrip ==>删除字符串左边的空格以及自定义字符；
names = "Hello" print(names.lstrip('He')) #删除字符串中左边空格以及自定义字符 #执行结果： llo
maketrans ==>用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串，表示转换的目标。注： 两个字符串的长度必须相同，为一一对应的关系。
intab = "abcde" outtab = "12345" trantab = str.maketrans(intab,outtab) str_new = "This is a test chengxu..." print(str_new.translate(trantab)) #执行结果： This is 1 t5st 3h5ngxu...
replace ==> 替换字符串中指定的字符，replace(self，old，new，count=None)
names_new = "hello" print(names_new.replace('hello','world')) #替换字符串指定的内容；replace(self, old, new, count=None) #执行结果： world
rfind ==> 查找字符串中指定字符的下标，如果指定的字符有多个，则返回最右边字符的索引下标，可以指定开始和结束的区间，如果没有，则返回-1；
names_new = "hello" print(names_new.rfind('x')) #查找字符串中指定字符的下标，如果指定的字符有多个，则返回最右边字符的索引下标，可以指定开始和结束的区间，如果没有，则返回-1； #执行结果： 3
rjust ==> 返回一个原字符串右对齐，并使用空格填充至长度width的新字符串。如果指定的长度小于原字符串的长度，则返回原字符串。
names_new = "hello" print(names_new.rjust(15,'#')) # rjust 返回一个原字符串右对齐，并使用空格填充至长度width的新字符串。如果指定的长度小于原字符串的长度，则返回原字符串。 #执行结果： ##########hello
split ==> 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串；从左边开始分割
names_new = "hello world hello world" #split 通过指定分隔符对字符串进行切片，如果参数num有指定值，则仅分割num个子字符串 print(names_new.split()) #split语法：str.split(str="", num=string.count(str)). str 分隔符，默认为空格，num为分割次数 print(names_new.split('h',1)) print(names_new.split('h')) #执行结果： ['hello', 'world', 'hello', 'world'] ['', 'ello world hello world'] ['', 'ello world ', 'ello world']
rsplit ==>通过指定分隔符对字符串进行切片，如果参数num有指定值，则仅分割num个子字符串；从右边开始分割
names_new = "hello world hello world" print(names_new.rsplit('h',1)) #执行结果： ['hello world ', 'ello world']
splitlines ==>按照行分割，返回一个包含各行作为元素的列表。
names_new = "hello\nworld\nhello\nworld" print(names_new.splitlines()) #执行结果： ['hello', 'world', 'hello', 'world']
startswith ==>检查字符串是否以某个字符开头，可以指定开始结束区间；
names_new = "hello" print(names_new.startswith('h')) #startswith 检查字符串是否以某个字符开头，可以指定开始结束的区间； #执行结果： True
strip ==>去掉字符串左边的空格；
names_new = " hello" print(names_new.strip()) #strip 去掉字符串左边的空格 #执行结果： hello
swapcase ==> 对字符串中的字母进行大小写转换；
names_new = "HELLO world" print(names_new.swapcase()) #对字符串中的字母进行大小写转换； #执行结果： hello WORLD
title ==>字符串中以符号分割的字母开头转为大写；
names_new = "hello world_hello" print(names_new.title()) #执行结果： Hello World_Hello
列表
append ==>追加，在原列表的最后追加字符串
name_list = ["wang","zhi","gang"] name_list.append("Hello") print(name_list) #执行结果： ['wang', 'zhi', 'gang', 'Hello']
clear ==>清空一个列表
name_list = ["wang","zhi","gang"] name_list.clear() print(name_list) #执行结果： []
count ==> 对列表中的值计数
name_list = ["wang","zhi","wang"] print(name_list.count("wang")) #对列表中的值计数 #执行结果： 2
extend ==>append和extend都仅只可以接收一个参数；append是任意，甚至是tuple；extend只能是一个列表；
name_list = ["wang","zhi","wang"] name_list.extend(["sun","mei","jun"]) #extend只能接收一个参数，只能是列表 print(name_list) #执行结果： ['wang', 'zhi', 'wang', 'sun', 'mei', 'jun']
extend和append对比：
#extend name_list = ["wang","zhi","wang"] name_list.extend("sun") #extend只能接收一个参数，只能是列表 print(name_list) #执行结果： ['wang', 'zhi', 'wang', 's', 'u', 'n'] #append name_list = ["wang","zhi","wang"] name_list.append("sun") #extend只能接收一个参数，只能是列表 print(name_list) #执行结果： ['wang', 'zhi', 'wang', 'sun']
index ==>打印列表值得索引下标
name_list = ["wang","zhi","gang"] print(name_list.index("gang")) #执行结果： 2
insert ==>指定列表的索引下标，在其前面插入值
name_list = ["wang","zhi","gang"] name_list.insert(1,"sun") print(name_list) # insert 指定列表的索引下标，在其前面插入值 #执行结果： ['wang', 'sun', 'zhi', 'gang']
pop ==>默认删除列表中最后一个值，可以指定下标删除
name_list = ["wang","zhi","gang"] name_list.pop() #pop 默认删除列表中最后一个值，可以指定下标删除 print(name_list) #执行结果： ['wang', 'zhi']
remove ==>移除列表中指定的值，不能指定下标进行移除。
name_list = ["wang","zhi","gang"] name_list.remove("wang") #remove 移除列表中指定的值,不能指定下标进行移除。 print(name_list) #执行结果： ['zhi', 'gang']
reverse ==>对列表倒序排列；
name_list = ["wang","zhi","gang"] name_list.reverse() #reverse 对列表倒序排列 print(name_list) #执行结果： ['gang', 'zhi', 'wang']
