Python Day02

• Z时代
• 2024-01-10
• 分类：综合

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']

以上是 Python Day02 的全部内容， 来源链接： utcz.com/z/388553.html