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
余数 22 ===>4 2的平方
25 ===>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 acctountuser_acctount and passworduser_password :
print(“success”)
else :
print(“fail”)
练习：输入1时返回apple，输入2时返回orange，输入3时返回banana，别的情况返回supermarket
print(“请输入a的值”)
a=int(input())
if a1:
print(“apple”)
else:
if a2:
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="|")
扫一扫
5926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
