python基础学习2

python中的运算符

1、算术运算符：用来做算术运算的符号

①、+ ：求和,也可以做连接符

②、 - ：求差

③、 * ： 求积

④、 / ：求商

⑤、% ：取余

⑥、//  ：取整

⑦、**  ：次方

注意：只能是数值

print(3*3) #求积结果:9
print(9/2) #相除结果：4.5
print(3**4) #3的4次方,结果：81
print(9//4) #小数部分直接丢掉，取整结果：2
print(13%3) #取余结果：1

　　运行结果是

9
4.5
81
2
1

　　比较运算符：用来比较(值只可能是布尔类型[真True或假False])

==    >    <    >=    <=    !=(不等于)

注意：== 比较字符串时，比较的是字符串的内容，其他比较都是数值(字符串的长度)

score = 80
print(score > 90)
print(score == 80)
print(score >= 60)
print(score != 80)

　　运行结果:

False
True
True
False

　　赋值运算符

=    +=(可以做连接符)    -=    *=    **=    /=    %=    //=

注意：赋值运算符的左侧一定是个变量，右侧一定要有个数据

= ：将右边的值给左边；其他：将两边的结果给左边

num = 3 #赋值
num += 6  #赋值
print(num)
num2 = 3 #赋值
num2 = num2 + 6 #赋值，等同于 num+=6(num+=6效率高些)
print(num2)
a = 10
a -= 5 #等同于 a = a - 5
print(‘-=的值：‘,a)
b = 10
b *= 5 #等同于 b = b * 5
print(‘*=的值：‘,b)
c = 12
c /= 5 #等同于 c = c / 5
print(‘/=的值：‘,c)
d = 11
d %= 5 #等同于 d = d % 5
print(‘%=的值：‘,d)
e = 10
e **= 5  #等同于 e = e * e * e * e * e
print(‘**=的值：‘,e)
f = 11
f //= 5  #等同于 f = f // 5
print(‘//=的值：‘,f)

#+= 用于连接字符串
strVale = ‘我爱你‘
strVale+=‘北京‘
print(strVale)

　　运行结果:

9
9
-=的值：5
*=的值：50
/=的值：2.4
%=的值：1
**=的值：100000
//=的值：2
我爱你北京

　　逻辑运算符：判断2个布尔值的关系

and且(&)    or或(|)    not非

注意：逻辑运算符 两侧必须是布尔值

score = 80
sex = ‘男‘
print(score>=60 and sex==‘女‘)  #建议此方法
print((score>=60) & (sex==‘女‘))
print(score>=60 or sex==‘男‘)  #建议此方法
print((score>=60) | (sex==‘男‘))
print(not(score>=60))

　　运行结果:

False
False
True
True
False

　　位运算法符

&    |    ^


python表达式和语句

python表达式和语句没有明显的划分

python表达式：是值，变量和操作符(或叫运算符)的组合。单独的一个值是一个表达式，单独的变量也是一个表达式

python语句：是一段可执行代码。常见的有赋值语句、if语句、while语句、for语句、return语句、import语句等等...

python赋值

变量名在首次赋值时会被创建，变量名在引用(使用)前必须先赋值

1、普通赋值

请参照：python中的运算符 -> 赋值运算符，的讲解！

2、序列赋值

python把赋值运算符右侧元组(列表)内的值和左侧元组(列表)内的变量相互匹配，然后每一次赋一个值

注意：左右元素的个数要相等，一一对应！

#序列赋值
a,b=1,2  #元组赋值 等同于  (a,b) = (1,2)
print(a,b)
[c,d] = [100,200]  #列表赋值
print(c,d)
e,f,g = ‘我爱你‘
print(e,f,g)

　　运算结果:

1 2
100 200
我 爱 你

　　扩展解包赋值

一个带星号的变量名 ，收集了序列中没有赋值给其他名称的所有项

注意：只能存在一个*号，多个*会造成无法区分范围

a,b,c = ‘你好啊‘
print(a,b,c)
a1,b1,*c1 = ‘你好啊TOM‘
print(a1,b1,c1)  #你 好 [‘啊‘, ‘T‘, ‘O‘, ‘M‘]
a2,*b2,c2 = ‘你好啊TOM‘
print(a2,b2,c2)  #你 [‘好‘, ‘啊‘, ‘T‘, ‘O‘] M
#a3,*b3,*c3 = ‘你好啊TOM‘  #报错，只能有一个 * 号
#print(a3,b3,c3)

　　运行结果:

你 好 啊
你 好 [‘啊‘, ‘T‘, ‘O‘, ‘M‘]
你 [‘好‘, ‘啊‘, ‘T‘, ‘O‘] M

　　多目标赋值(不建议使用)

num1,num2 = 3,4  #第一种方式
print(num1)
print(num2)
num3 = num4 =5  #第二种方式
print(num3)
print(num4)

　　运行结果:

3
4
5
5

　　条件语句 (if 语句控制程序的执行)

通过一条或多条语句的执行结果(True或False)来决定执行的代码块

if 语句的判断条件可以用>、<、==、>=、<=来表示其关系。

如果判断条件有多个时，可以使用and/or连接。

注意：

python 并不支持 switch 语句，所以多个条件判断， 只能用 elif 来实现。

Python程序语言指定任何非0和非空（None）值为true，0 或者 None为false。

每个选择分支，执行内容可以多行，以缩进来区分表示同一范围。

1、if 语句：格式一

    if 判断条件：

        执行语句……

解释：判断条件成立(值为True)，执行执行语句；否则不执行执行语句。

sex = ‘男‘
if sex == ‘男‘:
    print(‘语句执行...‘)
print(‘程序语句结束！‘)
print(‘----------------‘)
if sex == ‘女‘:
    print(‘语句执行...‘)
print(‘程序语句结束！‘)

　　运行结果:

语句执行...
程序语句结束！
----------------
程序语句结束！

　　if 语句：格式二

    if 判断条件：

        执行语句1…… 

    else：

        执行语句2……

解释：其中"判断条件"成立时（非零），则执行后面的语句(执行语句1)，else 为可选语句，当"判断条件"不成立时，执行(执行语句2)相关语句

注意：此格式的if语句，肯定有一个分支会被执行...

#肯定有一个会被执行...
sex = ‘男‘
if sex == ‘男‘:
    print(‘sex的值是男‘)
else:
    print(‘sex的值是女‘)
print(‘----------------‘)
sex = ‘男‘
if sex == ‘女‘:
    print(‘sex的值是女‘)
else:
    print(‘sex的值是男‘)

　　运行结果:

sex的值是男
----------------
sex的值是男

　　

if 语句：格式三

当判断条件为多个值时，可以使用以下形式：

 if 判断条件1: 

        执行语句1…… 

    elif 判断条件2: 

        执行语句2…… 

    elif 判断条件3: 

        执行语句3…… 

    else: 

        执行语句4……

score = 70
if score > 100:
    print(‘非常优秀‘)
elif score >80 :
    print(‘大于80分，优良‘)
elif score >=60:
    print(‘大于等于60分，良好‘)
else:
    print(‘不及格‘)

　　运行结果:

大于60分，良好

　　if 语句：格式四

如果判断条件有多个时，可以使用and/or连接。

当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比and/or要优先判断。

# 判断值是否在0~10之间
num01 = 9
if num01 >= 0 and num01 <= 10:
    print (‘Yes‘)
else:
    print (‘no‘)
print(‘----------------‘)
# 判断值是否在0~5或者10~15之间
if (num01 >= 0 and num01 <= 5) or (num01 >= 10 and num01 <= 15):
    print (‘hello‘)
else:
    print (‘undefine‘)

　　运行结果:

Yes
----------------
undefine

　　 python 复合布尔表达式计算采用短路规则，即如果通过前面的部分已经计算出整个表达式的值，则后面的部分不再计算。

a=0
b=1
#没报错，说明 b / a > 2没执行
if ( a > 0 ) and ( b / a > 2 ):
    print ("yes" )
else:
    print ("no")
#报错， b / a > 2 执行啦
a=0
b=1
if ( a > 0 ) or ( b / a > 2 ):
    print ("yes")
else :
    print ("no")

　　运行结果:

no
Traceback (most recent call last):
  File "../demoTest02.py", line 152, in <module>
    if ( a > 0 ) or ( b / a > 2 ):
ZeroDivisionError: division by zero

　　if 语句：格式五

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

    if 表达式1: 

        语句 

        if 表达式11: 

            语句 

        elif 表达式22: 

            语句 

        else: 

            语句 

    elif 表达式2: 

        语句 

    else: 

        语句

注意：只有进入外层的if，才有可能执行内层的if

score = 90
sex = ‘男‘
if score > 80:
    print(‘进入国家队‘)
    if sex == ‘男‘:
        print(‘男子队‘)
    else:
        print(‘进入女子队‘)
else:
    print(‘淘汰掉...‘)

　　运行结果:

进入国家队
男子队

　　if 语句：格式六 (不建议使用)

可以在同一行的位置上使用if条件判断语句

var = 100
# if后面只有一条语句，可以写在一行
if ( var  == 100 ) : print ("变量 var 的值为100")

　　运行结果:

变量 var 的值为100

注意：Python程序语言指定任何非0和非空（None）值为true，0 或者 None为false

if True:
    print(‘123‘)
if 124:
    print(‘123‘)

　　运行结果:

123
123

　　循环语句 (允许执行一个语句或语句组,多次)

Python提供了两种循环语句：while循环 \ for循环

while循环

判断条件为True时执行一次执行语句，然后再次判断条件。直到判断条件假False时，循环结束。

注意：使用while循环时别忘了写条件控制语句(循环退出的条件)，否则会变为死循环。

    while 判断条件：

        执行语句……

    案例1：输出0到10的整数

num01 = 0
while num01 <= 10 :
    print(num01)
    num01 += 1   #条件控制语句
print(‘循环结束...‘)

　　运行结果:

0
1
2
3
4
5
6
7
8
9
10
循环结束...

　　案例2：输出0到10的偶数 

#输出0到10的偶数
num01 = 0
while num01 <= 10 :
    if num01 % 2 ==0:
        print(num01)
    num01 += 1   #条件控制语句
print(‘循环结束...‘)

　　运行结果:

0
2
4
6
8
10
循环结束..

　　案例3：while … else 在循环执行结束后执行 else 语句块

#while … else 在循环执行结束后执行 else 语句块
num01 = 0
while num01 <= 10 :
    if num01 % 2 ==0:
        print(num01)
    num01 += 1   #条件控制语句
else:
    print(‘循环结束...‘)

　　运行结果:

0
2
4
6
8
10
循环结束..

　　案例4：while 后面只有一条语句，可以写在一行

#while 后面只有一条语句，可以写在一行
#不知道循环次数时，条件用True，内部控制循环退出...
#本案例的执行结果是，死循环......
while True: print(‘循环中.....‘)

　　for循环

    for  变量  in 序列: 

        语句

 注意：in:判断一个变量是否在序列中

1、简单应用

nums = [1,5,7,2,10]
for item in nums:
    print(item)

　　运行结果:

1
5
7
2
10

　　range() 代表整数区间

#range()只有一个参数：左边界默认从0开始，右边界为指定的值的前一个数
num1 = range(3)
for item in num1:
    print(item)
print(‘-------------‘)
#range()有两个参数，分别指定左右边界，但右边界为指定的值的前一个数
num2 = range(1,3)
for item in num2:
    print(item)
print(‘-------------‘)
#range()有三个参数，第三个参数代表步长
num3 = range(1,10,2)
for item in num3:
    print(item)

　　运行结果:

0
1
2
-------------
1
2
-------------
1
3
5
7
9

　　else中的语句会在循环正常执行完的情况下执行

#获得序列的索引
numbers = [1,5,7,2,10]
for item in range(len(numbers)):
    print(item)
else:
    print(‘循环结束‘)

　　运行结果:

0
1
2
3
4
循环结束

　　循环嵌套

外套环循执行一次，内层循环一轮

打印图形，外层控制行数，内层控制每行的*的个数

  ①、简单案例

for x in [‘田径队‘, ‘游泳队‘, ‘篮球队‘]:
    for y in [‘第一名‘, ‘第二名‘, ‘第三名‘]:
        print (x + y)

　　运行结果:

田径队第一名
田径队第二名
田径队第三名
游泳队第一名
游泳队第二名
游泳队第三名
篮球队第一名
篮球队第二名
篮球队第三名

打印4行5列矩形*号

#打印4行5列矩形*号
for x in range(4):
    for y in range(5):
        print(‘*‘,end="")
    print()

　　运行结果:

*****
*****
*****
*****

　　打印8行直角三角形*号

#打印8行直角三角形*号
for j in range(1,9):
    for i in range(j):
        print("*",end="")
    print()

　　运行结果:

*
**
***
****
*****
******
*******
********

　　打印乘法口诀表

#打印乘法口诀表
for j in range(1,10):
    for i in range(1,j):
        print("{0}*{1}={2};\t".format(i,j,j*i),end="")
    print()

　　运行结果:

1*2=2;
1*3=3;  2*3=6;
1*4=4;  2*4=8;  3*4=12;
1*5=5;  2*5=10;  3*5=15;  4*5=20;
1*6=6;  2*6=12;  3*6=18;  4*6=24;  5*6=30;
1*7=7;  2*7=14;  3*7=21;  4*7=28;  5*7=35;  6*7=42;
1*8=8;  2*8=16;  3*8=24;  4*8=32;  5*8=40;  6*8=48;  7*8=56;
1*9=9;  2*9=18;  3*9=27;  4*9=36;  5*9=45;  6*9=54;  7*9=63;  8*9=72;

　　循环控制语句

1、break语句用来终止所在的循环语句

#num的值会随着循环增大，在增大到5的时候，遇到break，循环退出
num = 0
while True:
    if num == 5:
        break
    print(num)
    num += 1
print(‘-------------------‘)
#在嵌套循环中，break只退出，break语句所在的循环，导致整个内层循环只执行了一次
for j in range(3):
    for x in range(3):
        print(‘hello...‘)
        break

　　运行结果:

0
1
2
3
4
-------------------
hello...
hello...
hello...

　　continue语句用来跳出所在循环体的本次循环，继续下一次循环

#到8就跳过
num02 = 0
while num02 <= 10:
    if num02 ==8:
        num02 +=1
        continue #在num02等于8时，退出当次循环，继续下一次循环
    print(num02 )
    num02 +=1
print(‘程序结束‘)

　　运行结果:

0
1
2
3
4
5
6
7
9
10
程序结束

　　


python基础学习2

原文地址：https://www.cnblogs.com/zhuhuibiao/p/12008157.html

时间： 2024-10-11 17:21:33

python基础学习2的相关文章

python基础学习日志day5-各模块文章导航

python基础学习日志day5---模块使用 http://www.cnblogs.com/lixiang1013/p/6832475.html python基础学习日志day5---time和datetime模块 http://www.cnblogs.com/lixiang1013/p/6848245.html python基础学习日志day5---random模块http://www.cnblogs.com/lixiang1013/p/6849162.html python基础学习日志da

Python 基础学习 网络小爬虫

<span style="font-size:18px;"># # 百度贴吧图片网络小爬虫 # import re import urllib def getHtml(url): page = urllib.urlopen(url) html = page.read() return html def getImg(html): reg = r'src="(.+?\.jpg)" pic_ext' imgre = re.compile(reg) imgli

python基础学习05（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #dict{键:值} #哈希 #注:字典是无顺序的,所以你懂的 #创建与赋值 dict1={} dict2={'name':'apply','avg':24,'sex':'man'} print dict1,dict2

Python基础学习（九）

Python 多线程 多线程类似于同时执行多个不同程序,多线程运行有如下优点: 使用线程可以把占据长时间的程序中的任务放到后台去处理. 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度 程序的运行速度可能加快 在一些等待的任务实现上如用户输入.文件读写和网络收发数据等,线程就比较有用了.在这种情况下我们可以释放一些珍贵的资源如内存占用等等. 线程在执行过程中与进程还是有区别的.每个独立的线程有一个程序运行的入口.顺序执行序列和程序的出口.

python基础学习07（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #file与input output #文件对象 #简单说来,就是写入和读取的方式 #file(),open()2个操作都是一样的,一般推荐open() #语法 # open(name[, mode[, bufferin

python基础学习08（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #异常 """ NameError: 尝试访问一个未申明的变量 ZeroDivisionError:  除数为零 SyntaxError: 解释器语法错误 IndexError: 请求的索引超出序列范

Python基础学习（十）

Python I/O模型 同步IO和异步IO,阻塞IO和非阻塞IO分别是什么,到底有什么区别?不同的人在不同的上下文下给出的答案是不同的.所以先限定一下本文的上下文. 概念说明 在进行解释之前,首先要说明几个概念: 用户空间和内核空间 进程切换 进程的阻塞 文件描述符 缓存 I/O 用户空间与内核空间 现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方).操作系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件

python基础学习12（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #python class #面向对象编程oop思想,3个特性:封装.继承.多态,在其他方面的功能,比如重载,模拟等,也可以自定义自己需要的类 #在python中,面向对象主要2个:类和类实例 #类与实例 #类与实例有关

python基础学习09（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #什么是函数 #就是引用,创建,使用 #例子 def foo(): print '233' foo() #返回与函数类型 def foo1():#是一个过程 print 'hello world!' foo1() foo

python基础学习11（核心编程第二版）部分

# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #执行环境 #可调用对象 """ 许多的python 对象都是我们所说的可调用的,即是任何能通过函数操作符“()”来调用的对象.要调用可调用对象, 函数操作符得紧跟在可调用对象之后.Python 有4