python要求将字符串循环右移n次_python 基础知识

[toc]

码好python的每一篇文章.

![]( https:// raw.githubusercontent.com /singvis/upload_image/master/img/python01.png )

1. 基础语法

1.1 注释

在编写代码的时候，有些代码不需要执行或增加代码说明，那么就需要用到注释了。

被注释的文本或代码是不会被执行的。

注释可以使用如下三种方式：

# 号

# 第一个注释，本行代码不会运行
print("hello world!") # 第二个注释

''' 三个单引号

也叫块注释，支持换行。

'''
第一行注释，本行代码不会运行
第二行注释，本行代码不会运行
第三行注释，本行代码不会运行
'''
print('hello world!')

""" 三个双引号

也叫块注释，支持换行。

"""
第一行注释，本行代码不会运行
第二行注释，本行代码不会运行
第三行注释，本行代码不会运行
"""
print('hello world!')

1.2 转义字符

常用的转义符：

转义字符描述 (行尾) 续行反斜杠() ` 单引号(') " 双引号( ") n 换行 r 回车 t Tab键(TAB)

行尾，用于续行

>>> print("www
.python.
org")
# 输出结果
www.python.org

''"，两个反双斜杠，转义为1个反斜杠

非正常结果示例：

>>> str = 'c:windowsnote'
>>> print(str)
# 输出结果：' n '当作换行来用了，才会出现如下情况
c:windows
ote

正常结果示例：

#把'n'改成'n'就可以解决了
>>> str = 'c:windowsnote'
>>> print(str)
# 修改后输出结果：
c:windowsnote

1.3 缩进

严格约定使用4个 空格 和一个 制表符 (tab)作为缩进，切记不能混用，否则报错IndentationError

def fun():
    print('hello world')
    print('hello world')

1.4 标识符

标识符的本质是对应具体数据结构的值，因该值不能被程序员直接访问，所以需要通过调用标识符来访问。

标识符格式定义的要求：

由字母(az)、数字(09)、下划线(_)组成；
不能以数字开头；
不能与python内置相同名；
字母大小敏感；
不能使用中文、也不建议用拼音

一切都是标识符。

错误标识符示例：

# 报语法错误，标识符不能以数字开头
>>> 123 = '123'
  File "<stdin>", line 1
SyntaxError: can't assign to literal

# 报语法错误，class是python语言类用到的，不能作为标识符
>>> class = 'abc'
  File "<stdin>", line 1
    class = 'abc'
          ^
SyntaxError: invalid syntax

保留标识符

FALSE await else import pass None break except in raise TRUE class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield

1.5 语言类型

python是动态语言、强类型语言。

动态编译语言

不用事先声明数据类型，可以随意赋值其他数据类型；
编程时不知道时什么类型，很难推断，这也是python的不好的地方，v3.8严格在这方便做改进；

# 标识符随意切换数据类型
x = 123        # 定义x为整数
x = '123'    # 定义x变为字符串

强类型语言

不同类型之间进行变量赋值时，需要显示地（强制）进行类型转换

>>> x = 123        # 定义x为整数
>>> y = '456'    # 定义y为字符串
# 报类型错误，不同类型不能相加
>>> print(x + y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'    
# 重新强制修改下为同类型        
>>> print(str(x) + y)
123456

1.6 运算符

1.6.1 算术运算符

常见的算术运算符：加(+)、减(-)、乘()、除(/)、取整(//)、取模(%)、幂(*)

加(+) 示例：

>>> test = 1 + 1
>>> print(test)
# 输出结果如下：
2

减(-) 示例：

>>> test = 1 - 1
>>> print(test)
# 输出结果如下：
0

乘(*) 示例：

>>> test = 1 * 1
>>> print(test)
# 输出结果如下：
1

除(/) 示例：

>>> test = 4 / 2
>>> print(test)
# 输出结果如下：
2.0    #结果是一个浮点类型

备注：注意python2.x /和//都是取整。

取整(//) 示例：说明：又叫做向下取整、地板除（往数值小的方向取整数）

>>> test1 = 5 // 2
>>> test2 = -5 // 2
>>> print('test1的结果：',test1)
>>> print('test2的结果：',test2)
# 输出结果如下：
test1的结果： 2        # 实际结果为2.5，靠近2，所以取2
test2的结果： -3    # 实际结果为-2.5，靠近-3，所以取-3

取模(%) 示例：如果都是正数，那么取余和取模都是余数，但特别要注意的地方是使用到正负数，这就要借助一个公式：

*模值*=x % y=x - [x // y] * y

>>> test1 =  5 % 3
>>> test2 = -5 % 3    #模值=-5 % 3=(-5)-[-5//3]*3=(-5)-(-2)*3=-5+6=1
>>> test3 =  5 % -3    #模值=5 % (-3)=5-[5//(-3)]*(-3)=5-(-2)*(-3)=5-6=-1
>>> test4 = -5 % -3    #模值=-5 % (-3)=-5-[-5//(-3)]*(-3)=-5-(1)*(-3)=-5+3=-2
>>> print('test1的结果：',test1)
>>> print('test2的结果：',test2)
>>> print('test3的结果：',test3)
>>> print('test4的结果：',test4)
# 输出结果如下：
test1的结果：  2
test2的结果：  1
test3的结果： -1
test4的结果： -2

幂(**) 示例：

>>> test =  2 ** 2
>>> print('tests的结果：',test)
# 输出结果如下：
test的结果： 4

1.6.2 位运算符

位与(&)、位或(|)、异或(^)、左移(<<)、右移(>>)

计算机的语言都是0 ,1 表示的二进制，位运算也是以二进制来计算的。

以下示例采用如下两个标识符进行计算:

x = 18    #10进制转为二进制：0001 0010
y = 20     #10进制转为二进制：0001 0100

位与(&) 示例：

说明：位与(&)是以二进制计算两者位都是 1 得 1 ,否则都是 0

>>> x = 18
>>> y = 20
>>> print('x & y 结果是：', x & y)
# 输出结果如下：
x & y 结果是： 16

位或(|) 说明：位或(|)是以二进制计算两者位有一个 1 得 1 ,否则都是 0

>>> x = 18
>>> y = 20
>>> print('x | y 结果是：', x | y)
# 输出结果如下：
x | y 结果是： 22

异或(^) 说明：异或(^)是以二进制计算两者位都有 1 得 0 ,有一个 1得1,其他为 0

>>> x = 18
>>> y = 20
>>> print('x ^ y 结果是：', x ^ y)
# 输出结果如下：
x ^ y 结果是： 6

左移(<<) 左移(<<)是整体向最高位(左边)移动位数。

>>> x = 18
>>> y = 20
>>> print('x 左移1位的结果是：', x << 1)
>>> print('y 左移2位的结果是：', y << 2)
# 输出结果如下：
x 左移1位的结果是： 36
y 左移2位的结果是： 80

右移(>>) 右移(>>)是整体向最低位(右边)移动位数。

>>> x = 18
>>> y = 20
>>> print('x 右移1位的结果是：', x >> 1)
>>> print('y 右移2位的结果是：', y >> 2)
# 输出结果如下：
x 右移1位的结果是： 9
y 右移2位的结果是： 5

1.6.3 比较运算符

常见的比较运算符：等于(==)、不等于(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)，返回的结果是布尔(bool)类型。

比较运算只能用于同一数据类型比较(除了==和!=)，比如：同数值类型比较、同字符串比较等。

>>> x = '18'
>>> y = 20
>>> print('比较的结果是：', x < y)
# 输出结果如下：不同类型不能比较
TypeError: '<' not supported between instances of 'str' and 'int'

等于(==) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x == y)
# 输出结果如下：
比较的结果是： False

不等于(!=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x != y)
# 输出结果如下：
比较的结果是： True

大于(>) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x > y)
# 输出结果如下：
比较的结果是： False

大于等于(>=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x >= y)
# 输出结果如下：
比较的结果是： False

小于(<) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x < y)
# 输出结果如下：
比较的结果是： True

小于等于(<=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x <= y)
# 输出结果如下：
比较的结果是： True

1.6.4 逻辑运算符

常见的逻辑运算符：与(and)、或(or)、非(not)

逻辑运算符返回的不一定是布尔类型(bool)，比如：1 and 'abc'返回的是‘abc’

另外，先提前了解下为假(False)对象有如下这些，易于理解：

与(and) 示例：

说明：所有条件为真(True)，返回结果才为真，否则为假(False)

  x = 1
  y = -1    #负数对象都是真(True)
  if x and y:
      print('x and y 均为真')
  else:
      print('x and y 其中有一个为假')
  # 输出结果如下：
  x and y 均为真
  ######################################
  x = 1
  y = ''    #空字符串对象都是假(False)
  if x and y:
      print('x and y 均为真')
  else:
      print('x and y 其中有一个为假')
  # 输出结果如下：
  x and y 其中有一个为假

或(or) 示例：说明：只要有一个条件为真(True)，返回结果为真，否则为假(False)

x = 1
y = []
if x or y:
    print('x or y 为真')
else:
    print('x or y 都为假')
#输出结果如下：
'x or y 为真
######################################
x = 0
y = []
if x or y:
    print('x or y 为真')
else:
    print('x or y 都为假')  
#输出结果如下：
x or y 都为假

非(not) 示例：说明：将真假对象置为相反，比如not 对象为True，则变为False，not 对象为False，则变为True

x = 1
if not x:
    print('其实x对象为假')
else:
    print('其实x对象为真')
#输出结果如下：
其实x对象为真
######################################
x = {}
if not x:
    print('其实x对象是假的')
else:
    print('其实x对象是真的')
#输出结果如下：
其实x对象为假

1.6.5 赋值运算符

先来个示例：x = 1, 赋值就是=号右边的数值1赋值给左边的变量x（记住始终先运行右边表达式）。

常见的运算符：=、+=、-=、=、=、%=、*=、=

另外，还可以使用链式赋值：x=y=z=1，即x=1,y=1,z=1

简单赋值示例：

>>> x = 1    #右边数值1赋值给了左边X
>>> y = 'hello'    #右边字符串'hello'赋值给了左边y

复杂赋值示例：

>>> x = 1
>>> x += 1    #等价于：x = x + 1，先运行=号右边表达式，在赋值给左边X
>>> print('x的结果是：',x)
#输出结果如下：
2

1.6.6 成员运算符

常见的成员运算符：in 和 not in 。

in 表示x的成员是否在目标y对象里面，如果有则返回True，否则返回False。

>>> x = 'a'
>>> y = 'abcdefg'
>>> print('x的成员在y里面：', x in y)    
#输出结果如下：
x的成员在y里面： True    # x的成员字符串'a'在y的成员字符串里面，所以结果为True

not in 表示x的成员不在目标y对象里面，如果不在返回True，否则返回False。

>>> x = 'a1'
>>> y = 'abcdefg'
>>> print('x的成员不在y里面：', x not in y)
#输出结果如下：
x的成员不在y里面： True    # x的成员字符串'a'在y的成员字符串里面，所以结果为True

1.6.7 身份运算符

身份运算符使用is 和 is not来判断标识符是否在内存地址引用同一对象。

身份运算符经常在字面上容易让大家踩坑，首先要区分下==和 is的区别：

==：指的是赋值的内容是否一样；
is：指的是标识符引用内存地址同一对象,使用id()函数来识别;

这里通过逻辑图演示一下，方便理解：

示例如下：

>>> x = ['a','b','c']
>>> y = ['a','b','c']
>>> print('x的ID是:',id(x))
>>> print('y的ID是:',id(y))
>>> print('x 和 y是否等价(=):',x == y)
>>> print('x 和 y是否在内存地址引用同一对象(id):',x is y)
#输出结果如下：
x的ID是: 1986422101448
y的ID是: 1986422101960
x 和 y是否等价(=): True
x 和 y是否在内存地址引用同一对象(id): False

1.6.8 运算优先级

我们先来看一个运算符例子,请问下该从哪一步算起、第二步...到最后返回的结果是啥？

-1 + 10 > 5 and 2 < 1
# 输出结果如下：
False

运算优先级，从上往下，优先级高到低：

1.7 内建函数

常见的内建函数：

内建函数名称函数签名说明 print print(value, sep=' ', end='n') 将数据输出到控制台，默认使用空格作为分隔符(sep)、换行(n) input input(value) 在控制台和用户交互，接收用户输入，并返回字符串 int int(value) 将数据转换成整数(int本质是类class) str str(value) 将数据转换成字符串(str本质是类class) type type(value) 判断对象是什么类型(本质是元类) isinstance isinstance(obj,tuple) 判断对象的类型

print 示例：

>>> print('www','python','org',sep='.',end='')    #字符串之间用sep='.'分割，end=''不换行
# 输出结果如下：
www.python.org

input 示例：

int 示例：

>>> x = '123'    # '123'为字符串
>>> y = int(x)    # int将字符串'123'转换为整数 123
>>> print('字符串转换为整数：',type(y), y)
# 输出结果如下：
字符串转换为整数： <class 'int'> 123

str 示例：

>>> x = 123
>>> y = str(x)
>>> print('整数转换为字符串：',type(y), y)
# 输出结果如下：
整数转换为字符串： <class 'str'> 123

type 示例：

>>> x = '123'
>>> y = 123
>>> print('x是什么类型',type(x))
>>> print('y是什么类型',type(y))
# 输出结果如下：
x是什么类型 <class 'str'>
y是什么类型 <class 'int'>

isinstance 示例：

>>> x = '123'
>>> y = 123
>>> print('x是整数吗？',isinstance(x, int))
>>> print('y是整数吗？',isinstance(y,(int,str))    #(int,str)位元组，或关系
# 输出结果如下：
x是整数吗？ False
y是整数吗？ True

1.8 循环语句

一个程序能否正常运行，必须的有顺序、分支、循环运行，如果条件控制不对就会导致死循环。

正常的顺序：从上到下一条条执行；

分支：分单分支和多分支，如条件满足则执行条件下的语句；

单分支

if 条件:
    代码块

# 示例：
x = 1
if x > 0:    #如条件为真，执行下面代码块
    print('hello world!')

多分支

if 条件1:
    代码块
elif 条件2:
    代码块
elif 条件3:
    代码块
...
else:
    代码块

# 示例：
x = 1
if x < 0:
    print("x是负数")
elif x==0:
    print('x是零')
else:
    print('x是正数')

循环：条件满足就反复执行，不满足就不执行；

常见的循环语句：for语句、while语句、continue语句、break语句；

for 语句标准格式：

for [元素] in [可迭代对象]:
    代码块

for 语句结合range()函数示例：

说明：range() 是惰性对象，需要去拨动它，拨一下便返回一个值

#range(stop)，range(5)表示[0,5)前包后不包,返回（0,1,2,3,4）序列，
for i in range(5):
    print(i)
# 输出结果如下：
0
1
2
3
4
#################################################
#range(start,stop,step),step表示步长
for i in range(0,10,2):
    print(i)
# 输出结果如下：
0
2
4
6
8

while 循环

说明：多用于死循环或不明确知道循环次数的场景。标准语句：
```
while 条件:
    代码块
```

死循环示例：

  #死循环
  while 1:
      print('这是死循环')

正常循环示例：

  x = 3
  while x:
      print(x)
      x -= 1
  # 输出结果如下：
  3
  2
  1

另外，思考下，上面结果为啥只有3 2 1。

continue

说明：continue是跳过当前循环的当次循环，继续下一次循环

  for x in range(10):
      if x % 2 == 0:
          continue
          print('这是不会执行的')    #永远都不会执行
      print(x)
      x -= 1
  # 输出结果如下：
  1
  3
  5
  7
  9

break 说明：结束当前循环
```
x = 0
while True:
    x += 1
    if x > 3:
        break
    print(x)
# 输出结果如下：
1
2
3
```
如果遇到循环有多层嵌套，要注意break只影响当前循环

如果喜欢的我的文章，欢迎关注我的公众号：点滴技术，扫码关注，不定期分享