文章目录

  • 1 Python3 介绍
  • 2 逻辑操作符
  • 3 闲聊
  • 4 数据类型
  • 5 查看变量类型
  • 6 优先级
  • 7 条件判断及循环
  • 8 列表
  • 9 元组
  • 10 字符串格式化



python中一切皆对象

1 Python3 介绍

IDLE：是python shell，一个交互界面

Windows系统上快捷键

  • alt+n：回到上一条命令
  • alt+p：回到下一条命令

Mac OS X系统上快捷键

  • ctrl+n：回到上一条命令
  • ctrl+p：回到下一条命令

python3中一行可以打印多个语句，例如：

>>> print("niahj");print("wosjoahore")	#自动换行
niahj
wosjoahore

也可以一句话多行写，如：

>>> 3 > \
  2
True
>>> (3 > 2 and
 2>1)
True

python3中可以给变量命中文名（因为3中源码文件默认使用utf—8编码，它是支持中文的）：

>>> 你是 = '好人'
>>> print(你是)
好人
>>>print("Well water" + "river")；
Well waterriver

>>>print("Well water\n" * 3)；#’\n’回车

在一个字符串中嵌入一个双引号：

  1. 可以用\反斜杠进行转义\”
  2. 或用单引号引起这个字符串

if guess == 8: #在后面加上:时回车会自动缩进

缩进是python的灵魂。

BIF：内置函数 python3用input()取代了python2的raw_input()
dir(__builtins__):查看python所有内置功能
help(功能)：可以查看每个BIF的用法

Python变量

  1. 要先赋值再使用。
  2. Python没有“变量“，只有“名字“。
  3. 变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
>>>first = 3
>>>second =8
>>>third = first + second
>>>print(third)
11

>>>str = ‘C:\now’

我们可以用反斜杠对自身进行转义：
>>>str = ‘C:\\now’

但如果对于一个字符串中有很多个反斜杠：
>>>str = ‘C:\Program Files\Intel\WiFi\Help’

原始字符串的使用非常简单，只需要在字符串前边加一个英文字母r即可：
>>>str = r‘C:\now’

若希望得到很长跨行的字符串，如：

人生的重大决定，
是由心规划的，
像一道预先计算好的框架，
等待着你的星座运行。
如期待改变我们的命运，
请首先改变心的轨迹。

这时我们就需要使用到三重引号字符串

“””人生的重大决定，
是由心规划的，
像一道预先计算好的框架，
等待着你的星座运行。
如期待改变我们的命运，
请首先改变心的轨迹。
“””

2 逻辑操作符

  1. and逻辑操作符 (相当于 && 与操作符)
  2. or逻辑操作符 （相当于 || 或操作符）
  3. not逻辑操作符 （相当于 ! 取反）

如 3>1 and 3>2 会返回true

短路逻辑：

if a and b：#如果a是false，那么跳过b的判断，结果直接false
if a or b：#如果a为true，那么跳过b的判断，直接true

若希望用户每次输入的数值都不一样则有以下办法
引入random模块，这个模块里面有一个函数叫做：randint()，它会返回一个随机的整数如：

import random		#先导入random模块
secret = random.randint(1,10)		#把随机出来的数赋值给secret。
print('-----我是好人-----')
temp = input("猜一下我现在心里所想的数字:")
guess = int(temp)
while guess !=secret:		#guess!= 的数值换成secret
    temp = input("哎呀，猜错了，请从新输入吧:")
    guess = int(temp)
    if guess == secret:
        print('哎呦，被你猜对了\n哼(￢︿̫̿￢☆),猜对了也没有奖励！')
    else:
        if guess > secret:
            print("大了，大了")
        else:
            print("小了，小了")
print("Game over!!!")

3 闲聊

python注释：
单行#，多行’’’ ‘’’ 或者 ““” ““”

e记法
若输入一个非常大的数，如150000000000，这样一直输入会很麻烦还容易出错，这时候就可以使用e记法。上面那个数字就变成了15e10或1.5e11都行。整数+、负数-。

4 数据类型

整型int()、浮点型float()和字符串str()之间转换。

由于True为1，False为0，故有以下算法：

>>>True + True
2
>>>True + False
1
>>>False + False
0

类似的可以进行一些*/操作
PS：在实际操作中最好不要这样写

字符串变整型

>>>a = ‘520’
>>>b = int(a)
>>>b
520

浮点型小数变整型
在python中，会将小数点后面的数删掉，只保留小数点前的数，如：

>>>a = 5.99
>>>b = int(a)
>>>b
5

字符串变浮点型或整型变浮点型

>>>a = ‘520’
>>>b = float(a)
>>>b
520.0

>>>a = 520
>>>b = float(a)
>>>b
520.0

整型变字符串

>>>a = 520
>>>b = str(a)
>>>b
‘520’		#会自动加上单引号

PS：若想得到我们正常思维的四舍五入值，则可以有以下方法
5.4 “四舍五入”结果为：5
int(5.4+0.5) == 5

5.6 “四舍五入”结果为：6
int(5.6+0.5) == 6
也就是多加了一个0.5

对字符串s的一些操作方法

方法

作用

s.isalnum()

所有字符都是数字或者字母，为真返回 Ture，否则返回False。

s.isalpha()

所有字符都是字母，为真返回 Ture，否则返回 False。

s.isdigit()

所有字符都是数字，为真返回 Ture，否则返回 False。

s.islower()

所有字符都是小写，为真返回 Ture，否则返回 False。

s.isupper()

所有字符都是大写，为真返回 Ture，否则返回 False。

s.istitle()

所有单词都是首字母大写，为真返回 Ture，否则返回 False。

s.isspace()

所有字符都是空白字符，为真返回 Ture，否则返回 False。

例如：

>>> s = 'I LOVE FISHC'
>>> s.isupper()
>>> True

5 查看变量类型

内置函数不要当成变量名来使用，如用str内置函数当成一个变量，若是如此，则当再使用str内置函数的时候就会报错。

若想要查看变量类型，可用type()内置函数如：

>>>a = ‘520’
>>>type(a)
<class ‘str’>

当然也可以使用isinstance()这个内置函数来查看变量类型，如：

>>>a = ‘520’
>>>isinstance(a,str)			#把变量a与str比较，是的话就显示True，错误的话就是False。
True
>>>isinstance(20,int)
True
>>>isinstance(20.3,float)
False

定义一个变量a 可用del a删掉

6 优先级

+、-、*、／（除法运算）、%（取余运算）、**（相当于^这个符号）、//（会把小数点后的数字删除掉）

优先级从大到小依次是
幂运算符：**正负号：-*、+*算术操作符：+、-、*、／、//比较操作符：<、<=、>、>=、==、!=逻辑操作符：and、or、not

7 条件判断及循环

（1）if条件操作
格式

if:

else:

elif:

条件表达式 --> 三元操作符，如：

# 条件表达式
x，y = 4，5
if x<y:
    small = x
else
    small = y
    
# 上面这个例子可以改为三元操作符
x,y = 4,5
small = x if x < y else y

语法：x if 条件 else y

（2）断言（assert）

assert这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。
一般来说我们可以用Ta再程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。

（3）for循环
格式：

for 目标 in 表达式：
    循环体

例如：

>>>favorite = ‘Rensongqi’
>>>for i in favorite:
	print(i, end=’ ’)


R e n s o n g q i


>>>member = [‘nihao’,’woshi’,’haoren’]
>>>for i in member:
	print(i,len(i))


nihao 5
woshi 5
happen 6

for循环还有一个小伙伴，range() 。
语法：range( [strat,] stop[, step=1] ) 这个BIF有三个参数，其中用中括号括起来的两个参数，表示这两个参数是可选的，step=1，表示第三个参数的默认值为1，即步长为1。
range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列。

# 例如：
>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]

#5默认表示从0到4这5个数
>>> for i in range(5):		
	print(i)

	
0
1
2
3
4


#(2,9)表示从2到8这7个数，不包括9
>>> for i in range(2,9):	
	print(i)

	
2
3
4
5
6
7
8


#(1,10,2)最后面的2表示步径为2，即从1开始，每次增加两个数到在1～9之间
>>> for i in range(1,10,2):	
	print(i)

	
1
3
5
7
9

（4）break&continue
**break：**跳出循环
**continue：**终止本轮循环，开始新一轮的循环

break例子（只有当输入你好啊or exit 的时候才会退出）：

bingo = '你好啊'
answer = input("请输入字符串：")

while True:
    if answer == bingo:
        print("真好啊!")
        break
    answer = input("哎呦，输入错误，请从新输入 or input exit to quit:")
    if answer == 'exit':
        break

continue语句例子：

for i in range(10):
    if i%2 != 0:
        print(i)
        continue

    i += 2
    print(i)


# 运行之后会输出以下数字：
2
1
4
3
6
5
8
7
10
9

8 列表

列表：（超级数组）
创建一个普通列表：member = [1,2,3,4,5,6,7]
创建一个混合列表：number = [‘我’,’是’,’好’,’人’,1.32,2,[1,2,3,4,5]]
创建一个空列表：empty = []

len(变量名) ：查看一个列表中的元素个数

用往列表中添加元素，如：
以下两个功能插入的时候都自动插入到列表的最后

  1. 可用append()功能来实现 number.append(‘nihao’)，然后回车就好了
    这一种办法每次只能添加一个元素，不能多添加元素
  2. 可用extend()功能来实现 number.append(‘nihao’)，回车
    这个办法每次也只能添加一个元素。
    也可以多添加几个元素，如：
    number.extend([‘niaho’,’hh’])，回车即可
    这个功能的含义就是把一个列表添加到另一个列表中，不能写成如下：
    number.extend(‘nihao’,’hh’)

insert()：把要插入的元素插入到列表的最前边，例：
number.insert(1,’可爱’) 把可爱这个字符串加入到列表前，但是此时1并不表示在第一位，而是在第二位，因为在列表中0是代表第一位的。

从列表中删除元素：

  1. remove() 里面直接输入删除的元素
  2. del 列表[n] 直接输入要删除列表中的位置
>>> member = ['wo','shi','hao','ren']
>>> member [3]
'ren'
>>> member.remove('shi')
>>> member
['wo', 'hao', 'ren']
>>> del member [1]
>>> member
['wo', 'ren']

3、pop()

>>> member
['wo', 'ren', 'hh', 'ee', 'qq', 'll']
>>> member.pop()
'll'
>>> member
['wo', 'ren', 'hh', 'ee', 'qq']
>>> name = member.pop()
>>> name
'qq'
>>> member
['wo', 'ren', 'hh', 'ee']
>>> member.pop(1)
'ren'
>>> member
['wo', 'hh', 'ee']

列表分片：

利用索引值，每次我们可以从列表获取一个元素，如果一次性需要获取多个元素，利用列表分片，可以简单的实现这个要求。
例如：只需要在数字之间加一个冒号即可，冒号前面的代表第一个索引号，后面的数字代表这个索引号前面的那一个索引号，在此例中即是3-1=2.

>>> member
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']
>>> member[1:3]		
['hh', 'ee']
>>>

分片后原列表并没有发生改变。
一些特殊操作：

>>> member
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']
>>> member[:3]			#冒号前不加数字代表从第一个元素开始到2索引号
['wo', 'hh', 'ee']
>>> member[1:]			#冒号后不加数字代表从第一个索引号开始一直显示到最后
['hh', 'ee', 'dd', 'ff', 'gg', 'hhh']
>>> member[:]			#两边都不加数字代表显示全部，这可以作为列表的拷贝使用
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']

列表常用操作符：

（1）比较操作符

>>> list1 = [123,456]
>>> list2 = [234,123]
>>> list3 = [123,456]
>>> list1 > list2
False
>>> list1 > list3
False
>>> list2 > list1
True

（2）逻辑操作符

>>> (list1 < list2) and (list1 == list3)
True

（3）连接操作符

>>> list4 = list1 + list2
>>> list4
[123, 456, 234, 123]

# PS:连接操作符左右两边类型必须一样

（4）重复操作符

>>> list1
[123, 456]
>>> list1 *=3		#这里的*号就是重复几次的意思
>>> list1
[123, 456, 123, 456, 123, 456]

（5）成员关系操作符

>>> 234 in list2
True
>>> 123 not in list2
False

# 定义一个列表中的列表
>>> list5 = [123,['wo','shi'],456]	

# 会发现返回False错误值，因为现在所写的list5是第一层，而‘wo’在第二层，所以有以下方法
>>> 'wo' in list5	
False

# list5[1]就是这个列表中的列表，这个时候再访问就能访问到了
>>> 'wo' in list5[1]	
True

# list5[1][1]表示这个列表中的列表的第二个元素
>>> list5[1][1]		
'shi'

列表的其他BIF内置函数：
（1）count：可以计算输入的元素在此列表中所出现的次数

>>> list3
[123, 456, 123, 456, 123, 456]
>>> list3.count(123)

（2）index：可以显示输入的元素的起始位置，后面还有两个参数，就是从3这个位置开始到5这个位置结束中间出现的起始位置

>>> list3.index(123)
0
>>> list3.index(123,3,5)
4

（3）reverse：可以吧这个列表中多有元素反转位置，也就是第一个跑到最后一个，以此类推

>>> list3.reverse()
>>> list3
[456, 123, 456, 123, 456, 123]
>>> list5		#但是对于有多层列表的列表来说，里面不能直接反转。
[123, ['wo', 'shi'], 456]
>>> list5.reverse()
>>> list5
[456, ['wo', 'shi'], 123]
>>> list5[1].reverse()	#这种做法就可以了
>>> list5
[456, ['shi', 'wo'], 123]

（4）sort：排序，默认从小到大排序

>>> list6 = [1,4,3,7,3,8,9,12,45,67,23,123]
>>> list6.sort()
>>> list6
[1, 3, 3, 4, 7, 8, 9, 12, 23, 45, 67, 123]

sort有3个参数，sort(func,key,reverse=False)
这里看最后一个参数，默认为False，改为True后就可以从小到大排序了

>>> list6.sort(reverse=True)
>>> list6
[123, 67, 45, 23, 12, 9, 8, 7, 4, 3, 3, 1]

（5）拷贝
以上述例子为例
member[:]：可以显示列表中全部的信息，但是member也可以直接显示全部的信息，这两个分别作为拷贝的源文件的时候有什么区别呢，看下面的测试：

>>> member
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']
>>> member1 = member[:]
>>> member1
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']
>>> member2 = member
>>> member2
['wo', 'hh', 'ee', 'dd', 'ff', 'gg', 'hhh']

# 现在看来，都是拷贝了的，没有什么区别
# 但是用一下list的BIF（ sort() ）后会发现一些问题的
# 先对member进行一下排序，排序成功
>>> member.sort()		
>>> member
['dd', 'ee', 'ff', 'gg', 'hh', 'hhh', 'wo']

# 再对member1进行一下排序，排序成功
>>> member1.sort()		
>>> member1
['dd', 'ee', 'ff', 'gg', 'hh', 'hhh', 'wo']

# 没有对member2排序，但是member2的顺序缺发生了改变
>>> member2			
['dd', 'ee', 'ff', 'gg', 'hh', 'hhh', 'wo']

由以上例子可以得出以下结论：

由member[:]拷贝而来的文件是真正拷贝成功的，但是以member拷贝而来的文件不是真正的拷贝成功，它只是member的另一个标签，相当于Linux中的软链接文件。前面说过，python的变量没有名字，只是一个标签而已，贴在哪里就是哪，和这个例子差不多意思，它只是多了一个标签而已，就像一个软链接一样，会随着源文件的变化而变化的。

9 元组

1、创建元组和访问元组

>>> tuple1 = (1,2,3,4,5,6,7,8)
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> type(tuple1)
<class 'tuple'>
>>> temp = (1)		#创建完后发现是int型而不是元组
>>> type(temp)
<class 'int'>
>>> temp = (1,)		#创建后是元组，究其原因，就是创建元组必须要有逗号，哪怕一个元素也要在其后面加上都好
>>> type(temp)
<class 'tuple'>
>>> temp1 = 2,3,4,5,
>>> temp1
(2, 3, 4, 5)
>>> type(temp1)
<class 'tuple'>

访问：（也能切片）

>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1[:]
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1[:4]
(1, 2, 3, 4)
>>> tuple1[3]
4

为了证明逗号（，）起决定性作用，下面有个例子：

>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)	
# 由此可见，加与不加逗号还是有很大的区别的

2、更新和删除一个元组
更新一个元组其内涵就是在想要改动的地方左右切片，切成两部分，然后加上一个元组，再组合在一块形成一个新的元组

>>> temp = ('ni','hao','wo','hao')
>>> temp = temp[:2] + ('aaa',) + temp[2:]
>>> temp
('ni', 'hao', 'aaa', 'wo', 'hao')

**删除元组：**del 删除整个元组；也可以通过切片删除元组中某一个元素

>>> temp = temp[:2] + temp[3:]
>>> temp
('ni', 'hao', 'wo', 'hao')

10 字符串格式化

格式化字符串就是按照统一的规格去输出一个字符串如果规格不统一，就很可能造成误会，例如十六进制的10跟十进制的10跟二进制的10完全是不同的概念！字符串格式化，正是帮助我们纠正并规范这类问题。

format()接受位置参数和关键字参数，二者均传递到一个叫做replacement的字段，而这个字段在字符串内由大括号表示{}。

1、位置参数：

>>> "{0} love {1}.{2}".format('I','you','aaa')
'I love you.aaa'
#通过{}大括号内的数来传递后面字符串所在的位置。

2、关键字参数：

>>> "{a} love {b}.{c}".format(a='I',b='you',c='aaa')
'I love you.aaa'

3、若要联合使用位置参数和关键字参数需要注意位置参数需在关键字参数之前：

>>> "{0} love {b}.{c}".format('I',b='you',c='aaa')
'I love you.aaa'
>>> "{a} love {0}.{b}".format(a='I','you',c='aaa')
SyntaxError: positional argument follows keyword argument   #这样就会出错


>>> '{0:.1f}{1}'.format(27.658,'GB')
'27.7GB'

上面这个例子中可以看到位置参数{1}和平常有些不同，后面多了个冒号。在替换域中，冒号表示格式化符号的开始.1的意思是四舍五入保留一位小数，f的意思就是定点数。所以按照格式打印出来了27.7GB。

>>> '%c'%97
'a'
>>> '%c %c %c' % (97,98,99)
'a b c'
>>> '%d + %d = %d' % (4,5,4+5)
'4 + 5 = 9'

>>> '%d转换为八进制是：%o' % (123,123)
'123转换为八进制是：173’
>>> '%d转换为十六进制是：%x' % (123,123)
'123转换为十六进制是：7b'
>>> '%5.1f' % 27.685
' 27.7'
>>> '%-5.1f' % 27.685
'27.7 '
>>> '%.2e' % 27.685
'2.77e+01'
>>> '%#o' % 10    #o表示八进制
'0o12'

--------------未完待续------------