Python的基本操作

Python超基础操作

组的表示方式：列表

定义一个列表的基本方式

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

可以是字符串、布尔类型、数字都是可以在列表中出现的
列表中也可以嵌套列表

[[1,2],[3,4],[True,False]]

（二维数组）嵌套列表

列表的函数和方法：

函数	意义
len（）	列表元素的个数
len（）	列表元素的个数
cmp（）	比较两个列表的元素
max（）	列表元素的最大值
min（）	列表元素中的最小值
list（）	将元组转化为列表
append（）	在列表末尾添加新的对象
count（）	统计某个元素在列表中出现的次数
extend（）	在列表末尾一次性追加另一个序列中的多个值
index（）	从列表中找出某个值第一个匹配项的索引位置
insert（）	将对象插入列表
pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove（）	移除列表中某个值的第一个匹配项
reverse（）	反向列表中元素
sort(cmp=None, key=None, reverse=False)	对原列表进行排序

访问某一列元素中的某一个元素

[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”][0] ===>“新月打击”
[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”][3] ===>“月神冲刺”
[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”][0:2] ===>[“新月打击”,“苍白之瀑”]
[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”][-1:] ===>[“月神冲刺”]

:的形式返回的是列表
索引的方式返回的是字符串
删除列表元素

list1 = [‘physics’, ‘chemistry’, 1997, 2000] del list1[2] print list1
===>[‘physics’, ‘chemistry’, 2000]

在已有的列表中添加一个列表

[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”]+[“混沌之球”,“安其拉”]
===>[“新月打击”,“苍白之瀑”,“月之降临”,“月神冲刺”,“混沌之球”,“安其拉”]

列表乘数字

[“点燃”,“爆炸”]*3 ===>[“点燃”,“爆炸”，“点燃”,“爆炸”，“点燃”,“爆炸”]

元组

（元组中的元组值是不允许删除的）
定义元组
(1,2,3,4,5,6)
(1,"-1",True)
可以是数字、字符串、布尔类型
删除元组 del 元组名称

查看元组中的内容

(1,2,3,4,5,6)[0] ===> 1
(1,2,3,4,5,6)[0:2] ===>(1,2)
(1,2,3)+(4,5,6) ===>(1,2,3,4,5,6)
(1,2,3)*3 ===>(1,2,3,1,2,3,1,2,3)

int整形 str字符串 list列表 class类 tuple元组

type((1,2,3)) ===>tuple
type(1) ===>int
type([1,2,3]) ===>list
type(“hello”) ===>str
type((1)) ===>int
type((1,) ===>tuple
type([1]) ===>list

元组的内置函数

函数	意义
cmp（）	比较两个元组元素
len（）	计算元组元素个数
max（）	元组元素的最大值
min（）	元组元素的最小值
tuple（）	将列表转化为元组

序列（组）的概念
str list tuple 都是序列

“hello world”[2] ===>“l”
[1,2,3][2] ===>3

切片操作

[1,2,3,4,5][0:3] ===>[1,2,3]
[1,2,3,4,5][-1:] ===>[5]
“hello world”[0:8:2] ===>“hlow”
in和not in
3 in [1,2,3,4,5,6] ===>True
3 not in [1,2,3,4,5,6] ===>False

列表的长度

len([1,2,3,4,5,6]) ===>6

字符串的长度

len(“hello world”) ===>11
max([1,2,3,4,5,6]) ===>6
man(“hello world”) ===>“w” 根据ascll
min([1,2,3,4,5,6]) ===>1

查看ascll码

ord(“w”) ===>119

set集合（无序,所以不可以用索引；不重复）
定义一个集合

type({1,2,3,4,5,6}) ===>set
{1,2,3,4,1,2,3,4} ===>{1,2,3,4}
len({1,2,3}) ===>3
1 in {1,2,3} ===>True
1 not in {1,2,3} ===>False

集合的特殊操作

(从第一个集合中剔除第二个集合中的元素 ) 求两个集合的差值

{1,2,3,4,5,6}-{3,4} ===>{1,2,5,6}

(在两个集合中找出相同的元素） 求两个集合的交集

{1,2,3,4,5,6}&{3,4} ===>{3,4}

(把两个集合合并到一块) 求两个集合的并集

{1,2,3,4,5,6}|{3,4,7} ===>{1,2,3,4,5,6,7}
type({}) ===>dict type(set()) ===>set
len(set()) ===>0

dict字典(集合类型,无序,不可以有重复的key）
定义一个字典(有很多的value，key）
{key1:value1,key2:value2,key3:value3,…}

type({1:1,2:2,3:3}) ===>dict

{“Q”:“新月打击”,“W”:“苍白之瀑”",E":“月之降临”,“R”:“月神冲刺”}
删除字典元素

dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}
del dict[‘Name’] # 删除键是’Name’的条目
dict.clear() # 清空字典所有条目
del dict # 删除字典 ===>字典不存在了

通过key访问/得到value

{“Q”:“新月打击”,“W”:“苍白之瀑”",E":“月之降临”,“R”:“月神冲刺”}[“Q”] ===>“新月打击”

value可以是任意的类型 str int float list set dict
key必须是不可变的类型 str int

type({“Q”:“新月打击”,“W”:“苍白之瀑”",E":{1:1},“R”:“月神冲刺”}) ===>dict

字典内置函数和方法：

函数/方法	意义
cmp（）	比较两个字典元素
len（）	计算字典元素个数，即键的总数
str（）	输出字典可打印的字符串表示
type（）	返回输入的变量类型，如果变量是字典就返回字典类型
clear（）	删除字典内所有元素
copy（）	返回一个字典的浅复制
fromkeys(seq, val)	创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
has_key（）	如果键在字典dict里返回true，否则返回false
items（）	以列表返回可遍历的(键, 值) 元组数组
keys（）	以列表返回一个字典所有的键
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.values（）	以列表返回字典中的所有值
pop(key,default)	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
popitem（）	随机返回并删除字典中的一对键和值

变量
变量 名字
定义一个变量(命名可读性要强）

A=[1,2,3,4,5,6]
B=[1,2,3]
A*3+B+A ===>[1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6,1,2,3]
skill=[“新月打击”,“苍白之瀑”]

变量名的规则：
1、只可以使用字母下划线数字
2、首字符不可以是数字
3、系统关键字，不可以用在变量名中 （保留关键字：系统关键字）
4、变量名是区分大小写的
（1）

a=1
b=a
a=3
print(b) ===>1

(2)

a=[1,2,3,4,5]
b=a
a[0]=”1”
print(a) ===>[“1”,2,3,4,5]
print(b) ===>[“1”,2,3,4,5]

int str tuple值类型（数值不可以改变） list set dict引用类型（数值可以改变）

a=”hello”
a=a+” python”
print(a) ===>”hello python”

id()—内存地址

b=”hello”
id(b) ===>55399200
b=b+”python”
id(b) ===>55336696

元组touple和列表list的区别

a=[1,2,3]
id(a) ===>59570576
hex(id(a)) ===>0x38cf99
a[0]=”1”
id(a) ===>59570576

追加元素append（）

a=(1,2,3)
b=[1,2,3]
b.append(4)
print（b） ===>[1,2,3,4]

(1)

a=(1,2,3,[1,2,4])
a[2] ===>3
a[3] ===>[1,2,4]
a[3][2] ===>4

(2)
a=(1,2,3,[1,2,[“a”,”b”,”c”]])中“b”的获取

a[3][2][1] ===>”b”

(3)

a=(1,2,3,[1,2,4])
a[3][2]=”4”
print(a) ===>(1,2,3,[1,2,”4”])

元组不可以改变，但是元组中的列表是可以改变的
Python的变量是不需要定义的

运算符

1、算数运算符 + - * / // %

“hello”+” world” ===>”hello world”
加法 [1,2,3]*3 ===>[1,2,3,1,2,3,1,2,3]
乘法 3-1 ===>2
减法 3/2 ===>1.5
除法 3//2 ===>1
整除 5%3 ===>2
余数 2 2 ===>4 2的平方
2 5 ===>32 2的五次方

2、赋值运算符= += -= /= %= *= //=
(1)

c=1
c=c+1
print© ===>2

简化:

c+=1
print© ===>3

(2)

a=3
b=2
b-=a
print(b) ===>1

(3)

b *=a
print(b) ===>3

3、比较（关系）运算符== != > < >= <=

1==1 ===>True
“a”>”b” ===>False
1<1 ===>False
1>=1 ===>True
1<=2 ===>True
1!=2 ===>True

4、逻辑运算符 and or not 且或非（操作布尔类型，返回不二类型结果）0是False，1是True
and 两个都为真的时候才为真，一个假就是假

True and True ===>True
True and False ===>False

or 有一个是真的就是真的，全假为假

True or False ==>True
Flase or False ===>False

not真就是假，假就是真

!True ===>False
!False ===>True

5、成员运算符 in not in

a=1
a not in [1,2,3,4,5] ===>False
b=6
b in [1,2,3,4,5] ===>False
c=”a”
c in {“c”:1} ===>False（是针对key值进行判断的）

6、身份运算符 is is not

a=1
b=2
a is b ===>False
a=”hello”
b=”world”
a not is b ===>True

如果两个变量的取值相等，则is返回True
值是否相等 is 不是比较值相等。is比较的是两个变量的身份时候相等
思考题

a={1,2,3}
b={2,1,3}
c=(1,2,3)
d=(2,1,3)
a==b ===>True 比较的取值是否相同，集合是无序的
a is b ===>False 比较两个变量的id地址
c ==d ===>False 元组是属于序列是有序的
c is d ===>False 比较两个变量的id内存地址

7、位运算符& | ^ ~ << >>

运算符	意义
&按位于	参与运算的两个值，如果两个相应位都为1，则该位结果为1，否则为0
按位或I	只要对应的二个二仅为有一个为1时，结果位就为1
^按位异或	当两对应的二进位相异时，结果为1
~按位取反	对数据的每个二进制位取反，即把1变为0，把0变为1
<<左移动	运算数的各二进位全部左移若干位，由<<右边的数字指定了移动的位数，高位丢弃，低位补0
>>右移动	把>>左边的运算数的各二进位全部右移若干位，>>右边的数字指定了移动的位数

如何判断变量的值、身份和类型？
A==b是对值的判断
A is b 是对身份的判断
类型 type 的判断
对象的三个特征：身份、类型、值（一切都是对象）
如何判断变量的类型？
(1)

a =”hello”
type(a) ==int ===>False

(2)判断变量的类型函数isinstance

isinstance(a,str) ===>True

运算符的优先级

括号的优先级是最高的（）
指数（最高）**
~ + - 按位取反、一元加号和减号
/ % // * 乘、除、取余、取整数
加法减法+ -
右移、左移运算符 << >>
& 按位于
^ |位运算符
<= < > >= 比较运算符
< > == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 是 不是
in not in在 不在
not and or 且或非 not> and>or

表达式：
表达式expression是运算符operator和操作数operand所构成的序列（操作数和运算符是由顺序的）
练习:
(1)

a=1
b=2
c=3
a+b*c ===>7

（2）a or b and c ===>1(先and后or）
练习

a=1
b=2
c=2
（not a） or （（b +2） ==c） ===>False

流程控制语句
条件控制 if else
(1)

mood = True
if mood :
print(“go to left”)
else :
print(“go to right”)

(2)

acctount = “qiyue”
password = “123456”
print(“please input acctount”)
user_acctount = input()
print(“please input password”)
user_password =input()
if acctount user_acctount and password user_password :
print(“success”)
else :
print(“fail”)

练习：输入1时返回apple，输入2时返回orange，输入3时返回banana，别的情况返回supermarket

print(“请输入a的值”)
a=int(input())
if a 1:
print(“apple”)
else:
if a 2:
print(“orange”)
else:
if a==3:
print(“banana”)
else:
print(“supermarket”)

循环控制语句for while
1、while
while condition:
代码
例子：
（1）

CONDITION=True
while CONDITION:
print(“I am while”)

一直进行循环模式，必须手动停止
(2)

counter = 0
while counter<=9 :
counter += 1
print(counter)
else :
print(“最强王者”)

当执行完while时，就会执行else中的代码
如何避免一直循环？
while后不可以为常量
2、for：主要是用来遍历/循环序列或集合、字典
for target_list in expression_list:
pass
例子：
（1）

a=[“apple”,“orange”,“banana”,“grape”]
for x in a:
print(x)

(2)

d=[[“apple”,“orange”,“banana”,“grape”],(1,2,3)]
for x in d:
for y in x:
if y== “orange”:
break
print(y)
else:
print(“fruit is gone”)

range(start,stop,step)函数
start:计数开始
stop：计数结束
step：步长
（1）range(0, -10, -1) # 负数

[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
for x in range(0,10,2):
print(x)

输出0 2 4 6 8
（2）

a=[1,2,3,4,5,6,7,8]
for i in range(0,len(a),2):
print(a[i],end="|")