python基础

表达式

在 Python 中，2 + 2 称为“表达式”， 它是语言中最基本的编程结构。表达式包 含“值”（ 例如 2）和“操作符”（ 例如+）， 并且总是可以求值（也就是归约）为单 个值。这意味着在 Python 代码中，所有使用表达式的地方，也可以使用一个值。

合法变量名

1．只能是一个词。

2．只能包含字母、数字和下划线。

3．不能以数字开头

基本函数

函数查询

dir(builtins)

help(int)

input()函数

这个函数求值为一个字符串，即用户输入的文本

len()函数

len('hello') #  字符串中字符的个数

5

str()、int()和 float()函数

str()函数可以传入一个整型值，并求值为它的字符串形式

str()、int()和 float()函数将分别求值为传入值的字符串、整数和浮点数形式

str(29) 

'29'

print('I am ' + str(29) + ' years old.')  #实现字符串与数字连接

I am 29 years old. 

int('42')
int(1.99)
int('99.99')#报错  int转换字符串时，字符串必须是整形

float('3.14')
3.14
float(10)
10.0

type函数

获取数据类型

type(99)

<class,‘int’>

isinstance

a=‘张张’

isinstance(a,str)  #对变量进行数据类型对比并得到布尔值

True

range()

range(start, stop[, step])

参数说明：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

运算符

​ ** 乘方

​ //表示整除 向下取整

​ 13//3 输出4

​ % 取模 返回余数

​ 13%3 得1

<< 左移 2<<2 2二进制10，向左移两位，1000，得到8

>> 右移 表示二进制表示下将数字右移

运算符优先权 由低到高

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments…)	函数调用
(experession,…)	绑定或元组显示
[expression,…]	列表显示
{key:datum,…}	字典显示
‘expression,…’	字符串转换

3 < 4 <5 等价于 (3<4) and (4<5)

Python 的做法是如果 x 为假，表达式会返回 x 的值(0)，否则它就会返回 y 的值

1 and 3 输出3

0 and 3 输出0

三元操作符

x if 条件 else y

x,y=4,5

if x<y :

​	small=x

else:

​	small=y

等价于small= x if x<y else y

控制流

布尔值

“布尔”数据类型 只有两种值：True 和 False。Boolean（布尔）的首字母大写，像其他值一样，布尔值也用在表达式中，并且可以保存在变量中。如果大小 写不正确，或者试图使用 True 和 False 作为变量名，Python 就会给出错误信息。

 True=1
 SyntaxError: cannot assign to True
    
    
'hello' == 'Hello' 
 False
 

True and False
False

比较运算符

==和!=操作符实际上可以用于所有数据类型的值。

布尔操作符 and or not

not > and > or

用于比较布尔值, not仅仅作用于一个布尔值

混合布尔和比较操作符

(4 < 5) and (5 < 6)

True

(4 < 5) and (9 < 6) 

False 

控制流语句

if语句

if 关键字；条件（即求值为 True 或 False 的表达式）；

冒号；

在下一行开始，缩进的代码块（称为 if 子句）。

if name == 'Alice':   
	print('Hi, Alice.') 

else语句

if name == 'Alice':       #一定要注意冒号

​	print('Hi, Alice.') 

else:     

​	print('Hello, stranger.')

elif语句

elif 语句是“否则如果”，总是跟在 if 或另一条 elif 语句后面

if name == 'Alice':     

	print('Hi, Alice.') 

elif age < 12:     #在elif语句后可以接else语句

	print('You are not Alice, kiddo.') 

for循环

for i in range(5):
	print(i)
else:
	print('over')

数组与列表

数组储存相同值

列表可以混合

普通列表

mix=[1,2,3,4]

混合列表

mix=[1,2,nihao,[1,2,3]]

mix

空列表

empty=[]

插入元素

append()方法（最后放插入一个）

向mix列表插入mm

mix.append(‘mm’)

extend()方法 多个插入,通过一个列表扩大另一个，也是后方插入

mix.extend([‘周吊’,‘薛老师’])

insert(列表中的位置,元素) 按位置插入

mix.insert(0,‘皮老板’)

从列表获取元素

index()方法

在列表中查找值 列表值有一个 index()方法，可以传入一个值，如果该值存在于列表中，就返回它 的下标。如果该值不在列表中，Python 就报 ValueError

spam = ['hello', 'hi', 'howdy', 'heyas'] >>> spam.index('hello')
0 
>>> spam.index('heyas')
3 

mix列表

mix[1]

mix[5]

若替换列表中两元素位置则需要加入一个新的变量用于存储被替换掉的变量

temp=mix[0]

mix[0]=mix[1]

mix[1]=temp

从列表删除元素

remove()

mix.remove(‘周吊’)

del语句

del mix[1]

del+列表名称，删除整个列表

pop()

pop方法默认是删除列表中的最后一个元素。 再将列表打印出来。

mix.pop()

打印最后一个元素

mix.pop(2)

打印第三个元素

获取多个元素 列表切片

mix[1:3],得到2-4个元素组成新的列表，但是源列表不变

mix[1:]

mix[:3]

mix[:] 列表拷贝

list1=mix[:]

注意还有步长的设置

list1= [1:5:2],步长为2

列表的常用操作符

+ * < >

列表拼接(一般不使用拼接，使用插入)

list3=list2+list1

list3
[456, 789, 123, 456]

*应用只能使得元素翻倍

list3*=3

比较符默认从第0个元素比较，第一个元素比较得到布尔值

in，not in

检测元素（单层，列表中的列表元素不可检测,单层检测）

‘123’ in list1

true

二层访问

list4=[1,2,3,['张','张'],4,5]

list4[3][1]

列表的bif

dir(list)

count使用

list4.count(元素)，计数

index 索引

list4.index(元素，开始检索位置，结束检索位置)，返回元素在列表位置

reverse 元素反转

list4.reverse()

sort 排序

默认从小到大

list4.sort()

从大到小

list4.sort(reverse=True)

迭代器和生成器

迭代器
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素，可使用for循环遍历
1
>>> print (next(it))
2
---------------------------------------------------------------------------
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

元组

字典

序列函数应用

序列

tuple1=(2,3,4,6)

len(tuple1)

max(tuple1)

min(tuple1)

sum(tuple1) # 要求序列是同类型

list(reversed(list1))

sorted() 排序 暂时排序不是永久性 sorted(tuple1)

enumerate() 枚举，返回元素位置和值，得到一个序列，需要转换

enumerate(tuple1)
<enumerate object at 0x000001E76FAC67C0> #list转换和tuple转换

zip() 生成小的元组 打包

a=[1,2,3,4,5,6]

b=[4,5,6,7]

list(zip(a,b))

[(1, 4), (2, 5), (3, 6), (4, 7)]

字符串的内置函数

原始字符串使用

常用于字符串内有多个\\的情况，在字符串前加上字母r即可

内置函数 onenote 内

字符串格式化

format方法

一.位置参数

​ （1）不设位置参数

print("{}的性别是：{}".format("小明","男"))

小明的性别是：男

​ (2) 设定位置参数

print("{0} {1}".format("Hello","World"))
print("{1} {0}".format("Hello","World"))
print("{0} {1} {0}".format("Hello","World"))
print("{1} {1} {0}".format("Hello","World"))

Hello World
World Hello
Hello World Hello
World World Hello

​ （3）通过序列传入

​ 在序列名前加上*，可实现传入

list1 = ["Hello","World"]
print("{} {}".format(*list1))   # 按照默认位置传入
print("{0} {1}".format(*list1))   # 按照指定位置传入
print("{1} {0}".format(*list1))   # 按照指定位置传入

Hello World
Hello World
World Hello

二,关键词参数

(1) 直接传入

print("{name}的身高是{height}".format(name="小明",height="180cm"))

小明的身高是180cm

(2)字典传入 字典前加两个**

kw = {"name":"小明","height":"180cm"}
print("{name}的身高是{height}".format(**kw))

小明的身高是180cm

格式化方法

grade = 97.556   # 浮点数取位数
print("我的成绩为：{:.2f}分".format(grade))

我的成绩为：97.56分  #浮点格式化
'{0}{1}{2:.2f}'.format('Pi = ','chi', 3.1415)#注意指定：.2f前的位置

'{a} {b}. {c}'.format(a='1',b='2',c='4')
'1 2. 4'

自身转义{}

print ("{}{{0}}".format("Hello"))

Hello{0}

%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	根据值的大小决定使用 %f 或 %e
%G	作用同 %g，根据值的大小决定使用 %f 或者 %E

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

格式化操作符辅助命令

符号	说明
m.n	m 是显示的最小总宽度，n 是小数点后的位数
-	用于左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示 ‘0o’，在十六进制数前面显示 ‘0x’ 或 ‘0X’
0	显示的数字前面填充 ‘0’ 取代空格

'%5.1f' % 27.777

'  27.7'  #左侧有空格 需占满5格 相当于右对齐

函数

def 	名称(参数1，参数2....):

	'函数文档放在第一行'

def add(num1,num2):  # num为形式参数
	result=num1+num2
	print(result)
add(1,2) #1,2为实参

参数

关键字参数

关键字参数，给实参下定义

def saysome(name,words):

	print(name + '->' +words)

saysome('张宇腾','你好')

saysome(words='你好',name='张宇腾')

收集参数（可变参数）

def add(*n):#加入*号即可
    ar = 0
    for x in n:
        ar = ar + x
    print(ar)
    return ar

add(1,2,5,7)

注意，可变参数与必选参数一起使用时，必选参数需要使用关键参数定义

默认参数

def dayin(name='zhangsan',age=18):
	print(name+str(age))


>>> dayin(age=79)
>>> zhangsan79

返回值

return

def back():
	return 1,2.3,'你好'
> back()
(1, 3, 'nihao')#默认元组

作用域

局部变量和全局变量

不要试图在函数内部修改全局变量

global语句

实现函数内修改全局变量

 def part():
	global spam
	spam='zhangzhang'
	print(spam)

嵌套函数

def function1():
	print('函数一被调用')
	def function2():
		print('函数二被调用')
	function2()
    
#function2不可以在全局中调用

闭包

def funX(x):
	def funY(y):
		return x*y
	return funY#不可以直接返回funY（）函数，会因为作用域报错

>>> funX(2)
<function funX.<locals>.funY at 0x0000021255FD3550>
>>> i=funX(2)
>>> i
<function funX.<locals>.funY at 0x0000021255FD3670>
>>> type(i)
<class 'function'>
>>> i(8)
16
>>> funX(5)(8) ###########
40

###nonlocal关键字
def fun1():
    x=5
    def fun2():
        x*=x
        return x
    return fun1()#报错，fun2试图修改fun1全局变量x，此时应该使用nonlocal
def fun1():
    x=5
    def fun2():
        nonlocal x
        x*=x
        return x
    return fun1()

fun1()
25

bin() 函数返回二进制数int类型

文件

open()

注意字符与字节

list(文件变量)可把文件内容变成列表

如何迭代打印出文件对象（f）中的每一行数据？

for each_line in f:

​ print(each_line)