当前位置: 澳门新濠3559 > 编程 > 正文

常量即指不变的量,     (2)编码比对

时间:2019-11-08 23:18来源:编程
# python基础语法 阅读目录: 一、知识点整理 前面已经介绍过几种基本语句(print,import,赋值语句),下面我们来介绍条件语句,循环语句。 一. print和import的更多信息 1.1 使用逗号输

# python基础语法

阅读目录:

一、知识点整理

前面已经介绍过几种基本语句(print,import,赋值语句),下面我们来介绍条件语句,循环语句。
一. print和import的更多信息
1.1 使用逗号输出
A.打印多个表达式,用逗号隔开,会在每个参数之间插入一个空格符:

### 变量与常量
声明变量:

1.变量

1、python2与python3的区别:

复制代码 代码如下:

```
name = "wualin"
```

2.用户与程序交互

     (1)宏观比对

>>> print 'age:',42
age: 42

##### 变量的定义规则:

3.基本数据类型

      python2 源码不标准,较为混乱,并且重复的代码很多。

B.同时输出文本和变量值,却又不希望使用字符串格式化:

  1. 变量名只能是字母,数字,下划线的任意组合
  2. 变量名的第一个字符不能是数字
  3. 关键字不能声明为变量名

4.格式化输出

      python3 源码统一了标准,同时也去除了重复代码。

复制代码 代码如下:

常量:常量即指不变的量,如pai 3.141592653..., 或在程序运行过程中不会改变的量
程序员约定俗成常量命名为大写字母

5.基本运算符

 

>>> name = 'Peter'
>>> greeting = 'Hello'
>>> print greeting,',',name
Hello , Peter

#### 程序交互:
读取用户输入

6.流程控制之if....else

     (2)编码比对

上面的例子中会在逗号前加入一个空格,我们可以这样优化:

```
name = input("What is your name?")

7.流程控制之while循环

      python2默认编码方式是ASCII。

复制代码 代码如下:

print("Hello " + name )
```

8.流程控制之for循环

      python3默认编码方式是utf-8(能识别中文)。

>>> print greeting + ',',name
Hello, Peter

以上程序会在输入后继续执行

9.开发工具IDE

      

注意,如果在结尾处加上逗号,那么接下来的语句会与前一句在同一行打印:

#### 注释:代码注释分单行和多行注释, 单行注释用#,多行注释可以用三对双引号""" """

10.扩展阅读

      PS:对应python2的编码问题,可以在代码首行处加入 #-*- encoding:utf-8 -*- 解决。

复制代码 代码如下:

### 基本数据类型:
#### 数字类型:
python3只有两种数字类型

11:作业

 

>>> print 'Hello,',
    print 'world'
Hello,world  

  1. 整型int()
  2. 浮点型float()

1.变量

#编码
中文编码有万国码、utf8、GBK
其中utf8中文占三个字节,GBK中文占两个字节,一个字节等于八位
其中utf8可以跟Unicode相互转化
GBK可以转变成unicode Unicode做中文处理的时候可以与GBK转化

1.变量必须由字母数字下划线组成2.数字不能作为开头3.不能是python中的关键字,最好不要跟python中内置的东西重复

2、python的环境分为“编译型”与解释型;

1.2 把某件事作为另一件事导入
从模块导入函数时,可以使用:
整个模块导入:import somemodule
导入其中一个函数:from somemodule import somefunction
导入其中几个函数:from somemodule import somefunction,anotherfunction,yetanotherfunction
导入全部函数:from somemodule import *
如果某2个模块都有相同名字的函数,比如叫open函数,那么可以这样给函数或者模块提供别名:

#### 字符串类型
在Python中,加了引号的字符都被认为是字符串。单引号和双引号没有任何区别
三引号用于多行字符串
字符串可以使用相加与相乘运算:

定义变量会有 id type value

注意:1.=比较的是vlaue
     2.is 比较的是id



强调:1.id相同,意味着type跟value必定相同
     2.value相同type不也相同,id可能不相同:
          x='juxianwen'
          y='juxianwen'
          id
          4376607152
          id
          4376607408
          x==y
          True
          x is y
          False

#1.在交互模式下
python实现int的时候由小数池。为了避免因为创建相同的值而重复申请内存空间所带来的效率问题,python解释器会再启动时创建出小数池,
范围是[-5,256],在该范围内的整数对象是全局解释器范围内被重复使用,永远不会被回收。(也就是说创建出来这个范围内相同的数字的id
相同)


#在pycharm中
在pycharm中会过大这个范围

 

复制代码 代码如下:

```
>>> name
'Alex Li'
>>> age
'22'
>>> name + age #相加其实就是简单拼接
'Alex Li22'
>>> name * 10 #相乘其实就是复制自己多少次,再拼接在一起
'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'
```

常量

常量是指不变的量,程序员约定俗成的用变量名全大写表示常量

#ps 在c语言中有专门的常量定义语法,const、int、count,一旦定义为常量,更改便会报错

      编译型指的是一次性将所有程序编译成二进制文件。

>>> import math
>>> import math as foobar
>>> foobar.sqrt(4)
2.0
>>> from math import sqrt as foobar2
>>> foobar2(4)
2.0

++字符串拼接只能是字符串与字符串拼接,不允许跟其他数据类型拼接++

2.用户与程序交互

#在python3中input:用户输入的任何值,都存成字符串类型#在python2中input:用户输入什么类型,就存什么类型raw_input:等于python3的input

完成一个用户程序交互:1.提醒用户输入用户名跟密码

2.获取用户名跟密码,如果用户名是:root 密码是:root 提示正确登录,否则登录失败

澳门新濠3559 1澳门新濠3559 2

1 name=input('请输入用户名:')2 pass_world=input('请输入用户密码:')3 if name=='root' and pass_world=='root':4     print('登录成功')5 else:6     print('登录失败')

输入用户名与密码

        优点:运行速度很快

二. 赋值魔法
就算是不起眼的赋值语句也有一些特殊的技巧。
2.1 序列解包
序列解包就是将多个值的序列解开,然后放到变量的序列中。

#### 布尔型(bool)
布尔类型:True(真) False(假),主要用于逻辑判断,例:

代码注释原则:

#1  不用全部都加注释,只是把自己觉得难理解的地方加上注释
 2. 注释可以用中文也可以用英文但是不要用拼音
 3.单行注释用# 多行注释用三对双引号"""  """

        缺点:开发效率低,不能跨平台执行

>>> #'多个赋值操作同时进行'
>>> x,y,z = 1,2,3
>>> print x,y,z
1 2 3
>>> #'交换2个或多个变量'
>>> x,y = y,x
>>> print x,y
2 1
>>> #'当函数或方法返回元组时'
>>> s = {'a':1,'b':2,'c':3}
>>> key,value =  s.popitem()
>>> print key,value
a 1
最后一个例子可以看出,它允许函数返回一个以上的值并打包成元组,然后通过一个复制语句很容易进行访问。
注意:解包的序列中元素数量必须和放置在赋值符合=左边的变量数量完全一致,否则会引发异常。

```
if a > b

三 基本数据类型

数字

#int 整型
定义:age=10  #age=int
功能:用于标识 工资 身高 体重

#int整形了解部分
在32位机器上,整型的位数为32位,取值范围为 -2**32~2**32-1
在64位系统上,整型的位数为64位,取值范围为-2**63~2**63-1



#long长整型
跟c语言不同,python的长整型没有指定位宽,即:python没有限制长整型的数值大小,但由于机器内存有限制所有我们使用的长整型不能
无限大。

注意在python2.2以后,如果整型发生溢出,那么python自动将整数数据转化为长整数,所以现在长整数数据后面不加字母L也不会产生严重
后果。


注意自python3以后不再有长整型,全部是int

整型的功能
1.如何将其他形式转化为整型:
  若a='123'
  b=int 这样子b=123 b就变成了一个整型

  num='0011'

Int(num,base=2)base=2是指以二进制的形式输出0011,base=16,是以16进制的形式进行输出,所以这个程序就是将0011以二进制的 形式进行转化为十进制,所以输出以后为3.

2.__.bit_length()的功能

这个的功能是这个数字用二进制表示至少需要几位

例如:age=10

R=age.bit_length()

Print

字符串

#在python中,加了引号的字符就是字符串类型,python并没有字符类型。
定义:name='jxw' 相当于name=str
用于标识:描述性内容,如姓名、性别等
len,join,for,索引切片 在别的数据结构中也能用

#那么单引号、双引号、多引号有什么区别呢?
单双引号没有什么区别,只有在下面这种情况你需要考虑单双号的配合。
msg=" I'am A"


多引号用于进行多行注释。

#字符串的加减
name='jxw'
age='18'
name+age  输出的是  jxw18 类型是字符串
name*5    输出的是 jxwjxwjxwjxwjxw 类型是字符串

注意1:字符串相加的效率不高
字符串1+字符串2,并不会在字符串1的基础上加上字符串2,而是申请一个全新的内存空间,存放字符串1和字符串2,所以占用了内存。
注意2:只能字符串加字符串,不能字符串加其他类型

#字符串的功能
1.字符串首字母大写
  text='alex'
  v=test.capitalize()
  print  输出的是Alex
2.大写变成小写
  test.casefold() 这条命令是不管什么国家的语言都可以变成小写
  test.lower() 这个是只能英文字符大写转化为小写
3.填补功能
  test='alex'
  v=test.ceter
  print
  输出的是        alex       空格加alex总共为20位
  v=test.cete
  print
  输出的是********alex********
4.计算字符串中某个字符的个数
  test='alexalex'
  v=test.count
  计算e在alexalex中出现多少次
  v=test.count从第二个位置到第七个位置ex出现了多少次,但是不包括第二个位置跟第七个位置
5.判断以什么结尾,以什么开头
 test='alex'
 test.endwith  看alex 在它的第二个位置到第四个位置是不是以a结尾的
 test.startwith 看alex是否以a开头
6.寻找目标所在位:
 test='alexalex'
 v=test.find 在第二个位置跟第五个位置寻找ex在哪个位置,寻找到第一个ex就不往后找了
7.将字符串中的占位符替换成指定的值
test='I am {name},age{a}'
test.format(name='alex',a=19) 输出I am alex,age19

相当于test='I am {name},age{name}'.format(**{name:'alex',age:19})字典形式得加**

test='I am {0},age{1}'test.format('alex',19)   输出I am alex,age19  按照顺序来的先0后1

test='I am {name}'.format('name'='xa')
test.format_map({'name':'alex'})输出的是 I am alex 
test='{0},{0}'.format输出的是11
test='i am {0[1]}'.format([1,2,3],[123])输出的[1,2,3]中的第二个元素 即 i am 2
test='{:s} {:d} {:f}'.format('sex',1,1.2) :s接受字符串 :d接受数字 :f接受浮点数 输出的是 sex 1 1.2
test='{:s} {:d}'.format(*['sex',12])  *['sex',12]是指的是输入整个列表 输出的是 sex 12

test='{:b} {:o} {:d} {:x}(16进制 输入小写abcd) {:X}(输入16进制 输入大写ABCD)
      {.%}(显示百分比默认显示小数点6位)'.format(15,1,15,15,15,15,8,2)



8.寻找字节在哪个位置

Text=’alexalex’

V=text.index

寻找a在哪个位置,如果没有4,5则默认从第零位开始,否则从第四位查找到第五位结束,

遇到一个a直接输出a的位置,这个a以后的则不查找,也就是说查找第一个a所在的位置。

9.判断字符串是否只包含字母与数字
test.isalnum 是的话是True不是的话Flase
10.断句换行功能
expandtabs在a个字符之内遇到t直接用空格填充到6
比如:s='ubatk'
     a=s.expandtabs输出的是uba  k总共位
断句,先将前6个拿出来无tab忽略再找6个,找到t后补充到6个
11.判断是否全为字母跟汉字
text.isalpha() 全是输出True 反之输出Flase
12.判断是否全为数字
test.isdecimal() 这个甚至可以判断特殊的数字比如① 二
test.isdigit()只能判断普通的数字
12.判断是否为标识符 
标识符=有字母数字下划线组成
test.isidentifier()是的话TRUE反之Flase
13.islower()判断是否为小写
14.判断是否可以打印
什么叫做可打印:如果存在t,n这些不可现实的字符就是不可打印
test.isprintable() 可打印true反之false
15.判断是否全为空格
test.isspace()判断是否全为空格
16.判断是否为标题
什么是标题:所有单词的首字母大写就是标题
test.istitle()
17.将字符串中的每个元素按照指定分隔符进行拼接
join(self,iterable)
test='你是风儿,我是沙'
t=' '
v=t.join 输出 你 是 风 儿 , 我 是 沙
18.填充字符

右填充 ljust
v='alex'
a=v.ljust 输出的是*alex
左填充
v='alex'
a=v.rjust输出的是alex*
左填充0
v='alex'
a=v.zfill输出的是0alex
19.判断字符串是否全为大写
test.isupper()
20.消除指定字符串
消除空格
test.strip()消除两边空格
test.lstrip()消除左边空格
test.rstrip()消除右边空格
n t 也可以消除 
test='nalex'
v=test.lstrip()这样输出的也是alex
消除指定的元素
test='xalex'
v=text.lstrip  输出的是alex
21.转变字符串的特定内容
test='你是风儿我是沙'
text1='去你妈的风和沙'
v='你是风儿我是沙,缠缠绵绵去你家'
将v中test内容换成test1中的内容
m=v.maketrans('你是风儿我是沙','去你妈的风和沙')
new_v=tanslate
22.分割
test='testastsd'
test.partition 输出的是 'te','s','tastsd' 只分割第一个s
test.rpartition从右起第一个s作为分割 'testast','s','d'
test.split 'te','ta','t','d'
可以指定分割次数test.split输出的是'te','tastsd'
从右开始分割 test.rsplit
22.根据换行符进行分割
test='anan'
v=test.splitlines()输出的['a','a']
v=test.splitlines输出的是['an','an']
v=test.splitline输出的是['a','a']
23.大小写转换
test='alex'
v=test.swapcase() 输出的是ALEX 
24.字符串的索引,切片,长度功能
test='alex'
索引 test[0] 输出的是a
切片 test[0:1] 输出范围 0=<x<1 
    test[0:-1]输出的范围是第一位到最后一位
长度 test='你是猪'
    len在python3中输出的是三,在python2中输出的是9 因为utf8中一个汉字占三位
    li=['2','1','0']
    len输出的是三
for zjw in test:
    print
相当于:
index=0
while index <len:
    v=test[index]
    print
    index=index+1
25.替换
test='alexalexalex'
test.replace('ex','bbb')输出的是albbbalexalex
test.replace('ex','bbb',2)输出的是albbbalbbbalex
26.创建连续的数字
v=range
print 输出的是range
for i in v:
     print 输出的是0到99
也可以设置步长
v=range
for i in v:
    print输出的是0 5 10 。。。。

#习题 将 文件索引打印出来
test=input#需要打印索引的内容
l=len
r=range
for k in r:
    print(k,test[k])

        语种:C/C++/GO/Swift/Object-C/Pascal等

2.2 链式赋值
链式赋值是将同一个值赋给多个变量的捷径。
>>> x = y = 'sss'

print(a is bigger than b )

列表

#在[]内用逗号分隔,可以存放n个任意类型的值 
定义:students=['1','2','3']
#students=list(['1','2','3'])
用于标识:存储多个值得情况,比如一个人的多个爱好

#存放多个学生的信息:姓名,年龄,爱好
student_info=[['egon',18,['play']],['alex',18,['play','sleep']]]
student_info[0][2],[0] 输出的是play
列表可以有索引、切片
列表可以进行for,while 自然也支持break contiune

链表:因为列表存储不是连续存的,就是在第一个位置里存放着第二个位置的坐标。正因为列表存储不连续,所以列表可以修改
     比如:列表第一个位置为20
          li[0]=120 第一个位置就由20变成120

1.删除,修改功能
del li[1] 将li的第二个位置删除掉
del li[2:6]删除li的 3,4,5,6位置的元素
li[1:3]=[120,90]第二位换成120,第三位换成90
2.列表中是否有这个元素
v=12 in li
print如果12在li中输出的True 如果不在输出Flase
3.取列表的特定的值
li=[1,12,9,8,['1',['19',10]],'alex',True]
li[4][1][0] 输出的是19
4.字符串转化为列表的原理
s='1234'
list
这个原理是
list=[]
for i in s:
    list=list.append
li=[1,2,3]
str输出的是'[1,2,3]'
5.末端插入
li=[1,2,3]
li.append
print输出的是[1,2,3,5]
5.清空列表
li.clear()
6.浅拷贝
li.copy
7.计算列表中元素出现了多少次
v=li.count看列表li中22出现了多少次
8.扩展列表,参数为可迭代对象
li=[11,22,33,44,55]
li=extend
print  输出的是[11,22,33,44,55,98,12]
9.从左往右找值,找到第一个就不继续找下去了
li=[11,22,33,44,55]
v=li.index #index(x,start,end)
10.在指定位置插入一个值
li=[11,22,33]
li.insert
print输出的是[99,11,22,33]
11.删除指定位置元素,并且可以获取到这个元素
li=[1,2,3]
v=li.pop()
print输出的是3
v=li.pop删除第二个位置的元素,并获取这个值赋值给v
12.删除指定元素
li.remove删除从左到右第一个22
13.将列表进行翻转
li=[1,2,3]
li.reverse()
print输出的是[3,2,1]
14.进行排列
li=[11,44,22,33,22]
li.sort
print 输出的是[11,22,22,33,44]
li.sort(reverse=True)
print输出的是[44,33,22,22,11]

#练习题
1.l=[1,2,3,4,5,6]
  正向步长:l[0:3:1] 输出的是[1,2,3]
  反向步长:l[2::-1]输出的是[3,2,1]
  列表翻转:l[::-1]输出的是[6,5,4,3,2,1]
2.用列表data=['alex',49,[1900,3,18]],分别取出列表中名字,年龄,出生的年,月,日赋值给不同的变量
  data[0]输出的是 alex
  data[1]输出的是 49
  data[2]输出的是 [1900,3,18]

 

2.3 增量赋值
增量赋值可以让代码更紧凑简练。
对于+,-,*,/,%等标准运算符都适用:

else

元组

列表:有序、[]、可以增删
元组:li=小括号,可以查看li[0](这里就已经证明元组是有序的),li[0:6],但是不可以修改跟删除,可迭代 for i in li: 
因为可以迭代所以 元组列表
     字符串可以相互转化。注意:元组的一级元素不可修改、删除、增加,但是二级元素确不一定不可以修改。
元组的join可以用
tu=('asdf','asdf')
v='_'join输出的是asdf_asdf
count计数
index获取指定元素在元组中的索引

      解释型指的是当程序执行时,编译器会将代码一行一行的解释。

>>> x = 2
>>> x += 1
>>> x *= 2
>>> x
6
>>> #对其他数据类型也适用
>>> f = 'foo'
>>> f += 'bar'
>>> f
'foobar'

print(a is smaller than b )
```

字典

字典的作用:可以存放多个任意类型的值,并且可以硬性规定值得映射关系。

#在{}内用逗号分隔,可以存放多个key,value的值,其中value可以是任意值,key只能是数字、字符串、布尔值,每一个值都有唯一一个
key对应,可以更为高效方便的取值。
注意:key重复时只能保留一个
     布尔值作为key时,True相当1,所以数字1跟True同时存在的时候只保留一个。False相当于数字0.

info={
     'name':'se',
     'hobbies':['play','sleep'],
     'company_info':{
          'name':'oldboy',
          'type':'edu'
          'emp_num':40
     }

}
print(info['company_info']['name']} 输出的是 oldboy
del infor name:se 这个键值对就被删除了

注意:字典不可以被while循环,但是可以进行for循环。
for i in infor:  相当于 for i in infor.keys(): 默认输出的是key
for i in infor.values():  这个是只循环初values
for i,v in infor.items(): 这个是将key value 都循环出来。
v='v1' in dic.values() 判断v1在没在value中出现

字典的功能:

1.clear清空功能

2.copy复制功能

3.fromkeys根据序列创建字典,并指定统一值。

v=dict.fromkeys(['k1',123,'99'])
print输出的是{123:None,'k1':None,'999':None}
4.字典的取值功能


v=dic.get取到k1这个键对应的值,如果没有输出None



v=dic.get('k11',111)输出k11键对应的那个值,如果没有输出111

5.字典的删除功能
v=dic.pop删除k1对应的那对键值对
print输出k1那个键对应的那个值

v=dic.pop
print如果字典中本来没有k1 这样就输出111
6.设置默认值
v=dic.setdefault('k1','123')如果k1存在则k1不设置成123,print将输出字典中的k1
如果k1不存在,那么将k1作为键123作为值放入字典中,print(dic['k1'])输出的是123
7.更新
dic.update({'k1':'1111','k2'=123}) 相当于 dic.(k1='1111',k2=123)
如果dic中k1已经存在,那么久覆盖掉,如果不存在更新上。

        优点:开发效率高,可以跨平台执行。

三. 语句块:缩排的乐趣
 语句块是条件为真时执行一次或多次的一组语句。在python中,冒号(:)用来标识语句块的开始,块中的每一个语句都是缩进的。当回退到和已经闭合的块一样的缩进量时,就表示当前块已经结束了。

#### 格式化输出

布尔值

#布尔值 一个True 一个False
bool将a转化为布尔值
#所有类型都自带布尔值
1.None,0,空 都为False
2.其余值都为True

        缺点:运行速度慢。

四. 条件和条件语句
4.1 这就是布尔变量的作用
下面的值在作为布尔表达式的时候,会被解释器看作假(False):
False None 0 “” () [] {}
其他的一切值都被解释为真,包括特殊值True。

```
name = input("Name")
age = input("Age")
job = input("Job")
hometwon = input("Hometwon")

重点

#可变类型:在id不变的情况下,value可变,则称为可变类型,如列表、字典。
#不可变类型:value一旦改变,id也得变,则成为不可变类型(id变,意味着创立新的内存空间)

        语种:JS/Python/Ruby/PHP/Perl/Erlang

4.2 条件执行和if语句
如果条件判断为真,那么后面的语句块就会被执行,也可以加入elif进行多个条件检查。作为if的一部分,还有else子句。
当然,我们可以在if语句里面嵌套使用if语句。

info ='''
----------info of %s -----------
Name : %s
Age : %s
Job : %s
Hometwon : %s
----------end-------------------
''' %(name, name, age, job, hometwon)
#%s = string
#%d = difit
#%f = float
print(info)
"""
```
info of %s中的%s就是一个占位符,这一行中的代表后面%(中的第一个)
%s在没有要求必须是数字或者小数的情况下是万能的

集合

#作用:去重、关系运算
#集合的定义:
   1.集合可以包括多个元素,用逗号分割开
   2.每个元素必须是不可变类型(可hash,可作为字典key)
   3.没有重复元素
   4.无序
例:s=set
   print输出的是{'h','e','l','o'}

   s=set(['alex','alex','sb'])
   print输出的是{'alex','sb'}

#集合的功能
1.添加元素
s={1,2,3}
s.add
print输出的是{1,2,3,s}
2.清空功能
s.clear()
print 输出的是set()
3.复制功能
s1=s.copy()
这个我相当于s1==s
4.删除功能
v=s.pop()这个是随机删除
v=s.remove指定删除元素1,如果没有1,则会报错
v=s.discard指定删除元素1,如果没有1也不会报错
5.交集
python_1=['lv','gh','gg']
linux_1=['lv','cnm','nmb']
python_and_linux=[]
for i in python_1:
    if i in linux_1:
        python_and_linux.append
python_and_linux=set(python_and_linux)    
这段程序相当于 p_s=set
            l_s=set
            print(p_s.intersection 相当于 print(p_s&l_s)
6.并集
print(p_s.union 相当于 print
7.差集:p_s中减去P_s与l_s的交集
print(p_s.different相当于print
进行差集以后,p_s与l_s并没有改变
p_s=p_s-l_s 相当于 p_s.different.updata  p_s就更新为 p_s-l_s
8.交叉补集:p_s并上l_s在减去p_s交上l_s
print(p_s.symmetric_difference 相当于 print
9.判断s1,s2集合是否为空
print(s1.isdisjoint若是为空则输出True
10.子集,复集   若s1为s2的子集,那么s2为s1的复集
子集:print(s1.issubset如果是子集输出True
复集 :print(s2.issuperset如果 s2>=s1那么输出True
11.不可变集合:
s=forzenset
通过这个命令形成的集合不可增加也不可删除

有如下列表
l=[
{'name':'alex','age' :18,'sex'='male'}

{'name':'egon','age' :73,'sex'='male'}

{'name':'alex','age' :20,'sex'='female'}

{'name':'alex','age' :18,'sex'='male'}

{'name':'alex','age' :18,'sex'='male'}

],去重,得到新列表并且保留原来顺序。

a=[{'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'alex', 'age': 73, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'female'},

    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},

   ]
b=[]


num=len



while num>0:

    num=num-1
    v=a.pop()


    for i in a:
        if i['name']==v['name'] and i['age']==v['age'] and i['sex']==v['sex']:
            a.remove#当a发生改变时直接跳出for 循环
    a.append

print

 

复制代码 代码如下:


数据类型总结

按存储空间的占用分

数字字符串集合:无序,即无序存索引相关信息元组:有序,需要存索引相关信息,不可变列表:有序,需要存索引相关信息,可变,需要处理数据的增删改字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改

       PS:Java和C#属于混合型语种;

num = input ('enter a number? ')
if num > 0:
    if num > 50:
        print"num > 50"
    elif num > 10:
        print "num > 10"
    else:
        print "num > 0"
else:
    print "num <= 0"

### 运算符
* 算数运算
* 比较运算
* 逻辑运算
* 赋值运算
* 成员运算
* 身份运算
* 位运算

四 格式化输出

程序中经常会有这样场景:要求用户输入信息,然后打印成固定的格式

比如要求用户输入用户名和年龄,然后打印如下格式:

My name is xxx,my age is xxx.

很明显,用逗号进行字符串拼接,只能把用户输入的名字和年龄放到末尾,无法放到指定的xxx位置,而且数字也必须经过str的转换才能与字符串进行拼接。

这就用到了占位符,如:%s、%d

#%s字符串占位符:可以接收字符串,也可接收数字
print('My name is %s,my age is %s' %('egon',18))
#%d数字占位符:只能接收数字
print('My name is %s,my age is %d' %('egon',18))
print('My name is %s,my age is %d' %('egon','18')) #报错

#接收用户输入,打印成指定格式
name=input('your name: ')
age=input('your age: ') #用户输入18,会存成字符串18,无法传给%d

print('My name is %s,my age is %s' %)

#注意:
#print('My name is %s,my age is %d' %) #age为字符串类型,无法传给%d,所以会报错

浮点数的格式化:

tp1='percent %f'%99.975 这个%f 默认保留6位 所以输出的是percent99.975000

tp1='percent%..2f'%99.9765 这个保留两位小数 输出的是 percent99.97

tp1='percent%..2f%%'%99.222 这个%%是指输出% 输出的是percent99.22%

字典的形式格式化:

tp1='i am %s age %d '%{'name':'alex','age':19}输出的是 i am alex age 19

print中的sep分割:

print('root','x','0','0',sep=':')这个值得是以:分割 输出的是 root:x:0:0:

       PS:python是一门动态解释型的强类定义语言;

4.3 更复杂的条件
下面我们回到条件本身,因为它们才是条件执行真正有趣的部分。
4.3.1. 比较运算符

##### 算数运算
假设x = 10,y = 20

五 基本运算符

计算机可以进行的运算有很多种,可不只加减乘除这么简单,运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算,今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算

算数运算

以下假设变量:a=10,b=20

澳门新濠3559 3

比较运算

以下假设变量:a=10,b=20

澳门新濠3559 4

赋值运算

以下假设变量:a=10,b=20

澳门新濠3559 5

逻辑运算

澳门新濠3559 6

#三者的优先级从高到低分别是:not,or,and>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3False#最好使用括号来区别优先级,其实意义与上面的一样>>> (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)False

身份运算

#is比较的是id#而==比较的是值

3、变量是将一些运算的中间结果暂存到内容当中,以便后续代码的调用。

复制代码 代码如下:

  1. 运算符(+)加-两个对象相加
  2. 运算符(-)减-得到负数或者一个数减去另一个数
  3. 运算符(*)乘-两个数相乘或返回一个被重复若干次的字符串
  4. 运算符(/)除-x除以y
  5. 运算符(%)取模-返回除法的余数
  6. 运算符(**)幂-返回x的y次幂
  7. 运算符(//)返回商的整数部分

六控制流程之 if....else语句

既然我们编程的目的是为了控制计算机能够像人脑一样工作,那么人脑能做什么,就需要程序中有相应的机制去模拟。人脑无非是数学运算和逻辑运算,对于数学运算在上一节我们已经说过了。对于逻辑运算,即人根据外部条件的变化而做出不同的反映,比如

# 如果:今天是Monday,那么:上班# 如果:今天是Tuesday,那么:上班# 如果:今天是Wednesday,那么:上班# 如果:今天是Thursday,那么:上班# 如果:今天是Friday,那么:上班# 如果:今天是Saturday,那么:出去浪# 如果:今天是Sunday,那么:出去浪#方式一:today=input('>>: ')if today == 'Monday':    print('上班')elif today == 'Tuesday':    print('上班')elif today == 'Wednesday':    print('上班')elif today == 'Thursday':    print('上班')elif today == 'Friday':    print('上班')elif today == 'Saturday':    print('出去浪')elif today == 'Sunday':    print('出去浪')else:    print('''必须输入其中一种:    Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday    ''')#方式二:today=input('>>: ')if today == 'Saturday' or today == 'Sunday':    print('出去浪')elif today == 'Monday' or today == 'Tuesday' or today == 'Wednesday'     or today == 'Thursday' or today == 'Friday':    print('上班')else:    print('''必须输入其中一种:    Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday    ''')#方式三:today=input('>>: ')if today in ['Saturday','Sunday']:    print('出去浪')elif today in ['Monday','Tuesday','Wednesday','Thursday','Friday']:    print('上班')else:    print('''必须输入其中一种:    Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday    ''')

        格式:变量名 = 值

 x == y;     x < y;     x > y;      x >= y;      x <= y;
 x != y;      x is y;     x is not y;   x in y;     x not in y;

##### 比较运算
假设变量x = 10,y = 20

七 流程控制之while循环

条件循环:while,语法如下

while 条件:        # 循环体     # 如果条件为真,那么循环体则执行,执行完毕后再次循环,重新判断条件。。。    # 如果条件为假,那么循环体不执行,循环终止

#打印0-10count=0while count <= 10:    print('loop',count)    count+=1#打印0-10之间的偶数count=0while count <= 10:    if count%2 == 0:        print('loop',count)    count+=1#打印0-10之间的奇数count=0while count <= 10:    if count%2 == 1:        print('loop',count)    count+=1

死循环

import timenum=0while True:    print('count',num)    time.sleep    num+=1  

循环嵌套与tag

 tag=True   while tag:    ......    while tag:      ........      while tag:        tag=False

#练习,要求如下:    1 循环验证用户输入的用户名与密码    2 认证通过后,运行用户重复执行命令    3 当用户输入命令为quit时,则退出整个程序 

#实现一:name='egon'password='123'while True:    inp_name=input    inp_pwd=input    if inp_name == name and inp_pwd == password:        while True:            cmd=input('>>: ')            if not cmd:continue            if cmd == 'quit':                break            print('run <%s>' %cmd)    else:        print('用户名或密码错误')        continue    break#实现二:使用tagname='egon'password='123'tag=Truewhile tag:    inp_name=input    inp_pwd=input    if inp_name == name and inp_pwd == password:        while tag:            cmd=input('>>: ')            if not cmd:continue            if cmd == 'quit':                tag=False                continue            print('run <%s>' %cmd)    else:        print('用户名或密码错误')

        命名要求:

4.3.2.  is:同一性运算符

   == |  等于-比较对象是否相等
  !=   |   不等于-比较两个对象是否不想等
  >  |  大于-返回x是否大于y
  <  |  小于-返回x是否小于y

continue break

break 是直接结束所有循环 continue结束当前循环在会到本层循环重新开始循环
while 1==1:(break直接回到这里并且结束这里)

while 1==1:(while 是结束循环回到这里并且继续执行循环)

a=input

if a=='a':

contiune

else:

break

while+else

#与其它语言else 一般只与if 搭配不同,在Python 中还有个while ...else 语句,while 后面的else 作用是指,当while 
循环正常执行完,中间没有被break 中止的话,就会执行else后面的语句count = 0while count <= 5 :    count += 1    print("Loop",count)else:    print("循环正常执行完啦")print("-----out of while loop ------")输出Loop 1Loop 2Loop 3Loop 4Loop 5Loop 6循环正常执行完啦-----out of while loop ------#如果执行过程中被break啦,就不会执行else的语句啦count = 0while count <= 5 :    count += 1    if count == 3:break    print("Loop",count)else:    print("循环正常执行完啦")print("-----out of while loop ------")输出Loop 1Loop 2-----out of while loop ------

while循环练习题

#1. 使用while循环输出1 2 3 4 5 6 8 9 10
#2. 求1-100的所有数的和
#3. 输出 1-100 内的所有奇数
#4. 输出 1-100 内的所有偶数
#5. 求1-2+3-4+5 ... 99的所有数的和
#6. 用户登陆
#7:猜年龄游戏
要求:

允许用户最多尝试3次,3次都没猜对的话,就直接退出,如果猜对了,打印恭喜信息并退出
#8:猜年龄游戏升级版
要求:
允许用户最多尝试3次

每尝试3次后,如果还没猜对,就问用户是否还想继续玩,如果回答Y或y, 就继续让其猜3次,以此往复,如果回答N或n,就退出程序
如何猜对了,就直接退出

#题一
count=1
while count <= 10:
if count == 7:
count+=1
continue
print
count+=1

count=1
while count <= 10:
if count != 7:
print
count+=1

#题目二
res=0
count=1
while count <= 100:
res+=count
count+=1
print

#题目三
count=1
while count <= 100:
if count%2 != 0:
print
count+=1

#题目四
count=1
while count <= 100:
if count%2 == 0:
print
count+=1

#题目五
res=0
count=1
while count <= 5:
if count%2 == 0:
res-=count
else:
res+=count
count+=1
print

#题目六
count=0
while count < 3:
name=input('请输入用户名:')
password=input
if name == 'egon' and password == '123':
print('login success')
break
else:
print('用户名或者密码错误')
count+=1

#题目七
age_of_oldboy=73

count=0
while count < 3:
guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1

#题目八
age_of_oldboy=73

count=0
while True:
if count == 3:
choice=input>>: ')
if choice == 'Y' or choice == 'y':
count=0
else:
break

guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1

            1)变量命名必须有数字、字母、下划线任意组合,但不能使用数字开头。

复制代码 代码如下:

>=|大于等于-返回x是否大于等于y
<=|小于等于-返回x是否小于等于y

for循环

for i in range:
    for t  in range:
        print
        break
输出的是 2,3,4,5,6,7,8为什么从2开始输出,因为开始i是1所以变成for t in range这个自动结束重新进行 for i in range就从2开始

            2)不能是python中的关键字,关键字的范围是“['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']”

澳门新濠3559,>>> x = y = [1,2,3]
>>> z = [1,2,3]
>>> x is y
True
>>> x is z
False
>>> x == z
True

##### 赋值运算
假设变量x = 10,b = 20

            3)变量具有可描述性,例如名称变量可定义为“name”,不能定义为“asss”。

由此看出,使用==运算符来判定两个对象是否相等,使用is判定两者是否同一个对象。

运算符 描述
= 简单的赋值运算符
+= 加法赋值运算符(c+=a等效与c=c+a)
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整数赋值运算符

            4)变量命名不能是中文。

4.3.3. in:成员资格运算符

##### 逻辑运算
运算符 | 描述
---|---
and |与-如果x为false,x and y返回false,否则它返回y的计算值
or |或-如果x是true,它返回true,否则它返回y的计算值。
not |非-如果x为true,返回false。如果x为false,它返回true

 

复制代码 代码如下:

##### 逻辑运算

4、常量就是一个一直不变的量,并且命名最好全部是大写。

name = raw_input("what is your name?")
if 's' in name:
    print 'your name contains the letter s'
else:
    print 'your name does not contain the letter s'  


 

4.3.4.字符串和序列比较
字符串可以按照字符顺序排列进行比较。
>>> 'alpha' < 'beta'
True
字符是按照本身的顺序值排列的,一个字母的顺序值可以用ord函数查到。
其他的序列也可以用同样的方式进行比较,不过比较的是元素的其他类型。

### 流程控制
* 单分支
* 双分支
* 多分支

5、注释是为了方便自己与他人更好的理解代码。

复制代码 代码如下:

##### 单分支

        单行注释:#

>>> [1,2] > [2,1]
False
>>> [1,[2,3]] < [1,[3,2]]
True  

```
if 条件:
满足条件后执行的代码
```
##### 双分支

        多行注释:'''被注释的内容'''  或  """被注释的内容"""

4.3.5. 布尔运算符
and运算符是所谓的布尔运算符,它连接2个布尔值,并且在两者都为真时返回真,否则返回假。与它同类的还有2个运算符,or和not。

```
if 条件:
满足条件后执行的代码
else:
if条件不满足执行的代码
```
##### 多分支

 

复制代码 代码如下:

```
if 条件:
满足条件后执行的代码
elif 条件:
上面条件不满足就执行这代码
else:
上面条件都不满足就执行这段
```

6、用户交互 input 输入命令:

number = raw_input("enter a number?")
if number <=10 and number >= 1:
    print "great!"


        1)等待用户输入内容;

4.3.6. 断言
if语句有个近亲,工作方式类似于:

### while循环
##### 语法:

        2)将输入的内容赋值给了前面的变量;

复制代码 代码如下:

```
while 条件:
执行代码。。。
```
使用while循环打印1-100:

        3)input 出来的数据类型全部是str类型;

if not condition:
      crash program

```
ount = 0
while count <= 100:
print("loop",count)
count+=1

 

这是因为与其让程序在晚些时候崩溃,不如在错误条件出现时直接让它崩溃。语句中使用的关键字是assert。它确保程序中的某个条件为真时才能让程序正常工作。

```
##### 死循环
while循环只要后面条件成立(也就是结果为真)就一直执行

7、基础数据类型可以分为三种3种, 数字、字符串、布尔类型(暂时介绍这三种)。

复制代码 代码如下:

例:

        int(整数型)

>>> age = -1
>>> assert 0 < age < 100
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    assert 0 < age < 100
AssertionError  

```
while True:
print("死循环")
```
##### 循环终止语句
* break:用于完全结束一个循环,跳出循环体执行循环后面的语句
* continue:与break类似,区别在于continue只是终止本次循环,接着还执行后面的循环,break则完全终止

        在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647

 五. 循环
 5.1 while循环
while语句非常灵活,可以在任何条件为真的情况下重复执行一个代码块。

break:

        在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807

复制代码 代码如下:

```
count = 0
while count <= 100:
print("loop",count)
if count == 5:
continue
count+=1

 

name = ''
while not name:
    name = raw_input('please enter your name: ')
print 'hello,%s!' % name

print("----end----")
```
continue:

        字符串转化成数字用法是 int(str) 

 5.2 for循环
当要为一个集合(序列和其他可迭代对象)的每个元素都执行一个代码块时,我们就需要for循环了。
5.2.1.循环遍历字典元素
一个简单的for语句就能循环字典的所有键,就像处理序列一样:
d = {'x':1,'y':2,'z':3}
for key in d:
    print key,'corrensponds to ',d[key]
5.2.2.一些迭代工具
A.并行迭代

```
count = 0
while count <= 100:
print("loop",count)
if count == 5:
continue
count+=1

            ps:str必须是数字组成的

复制代码 代码如下:

print("----end----")
```
##### while else
while后面的else作用是指,当while循环正常执行完,中间没有被break终止的花,就会执行else后面的语句

 

names = ['a','b','c','d']
ages = [12,23,45,32]
#循环索引迭代
for i in range(len(names)):
    print names[i],'is',ages[i],'years old.'
#内建zip函数迭代
for name,age in zip(names,ages):
    print name,'is',age,'years old.'

###### 作用:用来测试循环是否执行完毕,判断循环是否有异常

        数字转化成字符串用法是 str(int)

B.编号迭代
有时候迭代序列中的对象时,同时要获取当前对象的索引。

 

 

复制代码 代码如下:

  

        long(长整数型)

#index计数
index = 0
for string in strings:
    if 'xxx' in string:
        string[index] = 'sss'
    index += 1

        跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。

#内建enumerate函数迭代
for index,string in strings:
    if 'xxx' in string:
        string[index] = 'sss'

 

C.翻转和排序迭代
函数reversed和sorted,作用于任何序列或可迭代对象上,不是原地修改对象,而是返回翻转或排序后的版本:

        PS:自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。

复制代码 代码如下:

        注意:在Python3里不再有long类型了,全都是int

>>> sorted([2,6,3,7])
[2, 3, 6, 7]
>>> list(reversed('hello'))
['o', 'l', 'l', 'e', 'h']

 

 5.3 跳出循环
一般情况下循环会一直执行到条件为假,或者到序列元素用完时。但是有时候需要提前中断一个循环。
5.3.1.break
结束循环可以使用break语句。

        str(字符串类型)

复制代码 代码如下:

        python当中凡是用引号(单引号或双引号)引起来的都是字符串。

for i in range(0,10):
    if i == 5:
        print 'quit'
        break
    print i

            特性:

5.3.2.continue
continue语句会让当前迭代结束,跳到下一轮循环的开始。

                    可相加:字符串的拼接。

复制代码 代码如下:

                    可相乘:str * int 

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

 

5.3.3.while True/break
比如当用户在提示符下输入单词时做一些事情,并在用户不输入单词后结束循环。

        bool(布尔值)

复制代码 代码如下:

        分为True和False两种。

while True:
    word = raw_input('enter a word: ')
    if not word:
        break
    print 'The word is '+ word

 

六. 列表推导式--轻量级循环
列表推导式是利用其他列表创建新列表的一种方法,工作方式类似于for循环:

二、基础命令整理

复制代码 代码如下:

1、print 打印输出命令,例如 print(123) 或 print('一二三')

>>> [x**2 for x in range(10) if x % 3 == 0]
[0, 9, 36, 81]
>>> [(x,y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)  

2、type 是一个内建的函数,调用他能够得到一个返回值,从而知道想要查询的对象类型信息,例如print(123,type(123))

 七. 三人行
作为最后的结束,我们来看3个语句:pass,del和exec
pass:什么都不做,用来在代码中做占位符使用,方便调试代码。

3、input 输入命令,程序会等待用户输入值,值全部是字符类型。例如变量name = input('请输入您的名字!') 

复制代码 代码如下:

4、''单引号:当字符串中包含双引号时,可以用单引号引起来。

if a == 'a':
    print 'yes'
elif a == 'b':
    pass
else:
    print 'no'

     ""双引号:当字符串中包含单引号时,可以用双引号引起来。

del:删除不再使用的对象,也就是用作垃圾收集。

     """多引号:当字符串是多行内容时,必须要用多引号引起来。

复制代码 代码如下:

5、字符串拼接:

>>> x = [1,2]
>>> y = x
>>> del x
>>> x
Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>> y
[1, 2]  

     例如 name + age ,表示name变量(str)拼接上age变量(str)

del删除的只是名称,而不是列表本身,所以上面的例子中,删除x不会影响到y。
exec:动态创造python代码,然后将其作为语句执行或作为表达式计算。但是这样做是会有很严重的潜在安全漏洞,如果程序将用户提供的一段内容中的一部分字符串作为代码执行,程序可能会失去对代码执行的控制。

             name * 10 ,表示输出name变量(str)值10此,并且将其全部拼接在一起。

复制代码 代码如下:

6、运算符介绍:

>>> exec "print 'hello,world'"
hello,world

澳门新濠3559 7

一. print和import的更多信息 1.1 使用逗号输...

7、逻辑运算:

 澳门新濠3559 8

  逻辑运算分为 and 、 or 、 not 三种。

        1)在没有()的情况下,not 优先级高于 and ,and优先级高于 or ,即关系为 () > not > and > or ,同一优先级从左往右计算。

 

        2)x or y , x 为真,值就是x,相反 x 为假,那么值就是 y;

             x and y , x 为真,值是 y,相反 x 为假,那么值就是x;

 

        3)or  和 and 的返回值正好相反。

 

  or:

      只要有一个True,就会返回True

      PS:如果程序首先看到True,就不会再看or 后面的条件。

  and

      只要有一个False,就会返回False

       PS:如果程序首先看到False,就不会再看and 后面的条件。

 

8、赋值运算:

澳门新濠3559 9

9、if 流程控制语句

    单分支格式:

            if 条件:

                满足条件执行代码

 

    双分支格式:

            if 条件:

                满足条件执行代码

            else:

                if条件不满足就走这段代码

 

    多分支格式:

            if 条件:

                满足条件执行代码

            elif 条件:

                上面条件不满足就走这个

            elif 条件:

                上面条件不满足就走这个

            elif 条件:

                上面条件不满足就走这个

            elif 条件:

                上面条件不满足就走这个

10、while循环语句

        基本循环格式:

            while 条件:

                # 循环体

          

        循环终止语句:

            1)break:完全终止循环

            2)continue:单次终止循环

 

   while else:

    当while循环正常执行完,中间没有被break中止的话,就会执行else后面的语句。

 

11、格式化输出 - 占位符

        %s 表示字符串占位符;

        %d 表示数字占位符;

        %% 会被解析成字符%,如%%s 解析成 %s

 

 

编辑:编程 本文来源:常量即指不变的量,     (2)编码比对

关键词: