1stweek.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8dbcefe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      S.__format__(format_spec) -> str\n",
      " |      \n",
      " |      Return a formatted version of S as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      S.__sizeof__() -> size of S in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(...)\n",
      " |      S.capitalize() -> str\n",
      " |      \n",
      " |      Return a capitalized version of S, i.e. make the first character\n",
      " |      have upper case and the rest lower case.\n",
      " |  \n",
      " |  casefold(...)\n",
      " |      S.casefold() -> str\n",
      " |      \n",
      " |      Return a version of S suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(...)\n",
      " |      S.center(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S centered in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space)\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(...)\n",
      " |      S.encode(encoding='utf-8', errors='strict') -> bytes\n",
      " |      \n",
      " |      Encode S using the codec registered for encoding. Default encoding\n",
      " |      is 'utf-8'. errors may be given to set a different error\n",
      " |      handling scheme. Default is 'strict' meaning that encoding errors raise\n",
      " |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n",
      " |      'xmlcharrefreplace' as well as any other name registered with\n",
      " |      codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(...)\n",
      " |      S.expandtabs(tabsize=8) -> str\n",
      " |      \n",
      " |      Return a copy of S where all tab characters are expanded using spaces.\n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found, \n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(...)\n",
      " |      S.isalnum() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphanumeric\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isalpha(...)\n",
      " |      S.isalpha() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphabetic\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isdecimal(...)\n",
      " |      S.isdecimal() -> bool\n",
      " |      \n",
      " |      Return True if there are only decimal characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isdigit(...)\n",
      " |      S.isdigit() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are digits\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isidentifier(...)\n",
      " |      S.isidentifier() -> bool\n",
      " |      \n",
      " |      Return True if S is a valid identifier according\n",
      " |      to the language definition.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers\n",
      " |      such as \"def\" and \"class\".\n",
      " |  \n",
      " |  islower(...)\n",
      " |      S.islower() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are lowercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  isnumeric(...)\n",
      " |      S.isnumeric() -> bool\n",
      " |      \n",
      " |      Return True if there are only numeric characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isprintable(...)\n",
      " |      S.isprintable() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are considered\n",
      " |      printable in repr() or S is empty, False otherwise.\n",
      " |  \n",
      " |  isspace(...)\n",
      " |      S.isspace() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are whitespace\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  istitle(...)\n",
      " |      S.istitle() -> bool\n",
      " |      \n",
      " |      Return True if S is a titlecased string and there is at least one\n",
      " |      character in S, i.e. upper- and titlecase characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |      Return False otherwise.\n",
      " |  \n",
      " |  isupper(...)\n",
      " |      S.isupper() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are uppercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  join(...)\n",
      " |      S.join(iterable) -> str\n",
      " |      \n",
      " |      Return a string which is the concatenation of the strings in the\n",
      " |      iterable.  The separator between elements is S.\n",
      " |  \n",
      " |  ljust(...)\n",
      " |      S.ljust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S left-justified in a Unicode string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(...)\n",
      " |      S.lower() -> str\n",
      " |      \n",
      " |      Return a copy of the string S converted to lowercase.\n",
      " |  \n",
      " |  lstrip(...)\n",
      " |      S.lstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(...)\n",
      " |      S.partition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, and return the part before it,\n",
      " |      the separator itself, and the part after it.  If the separator is not\n",
      " |      found, return S and two empty strings.\n",
      " |  \n",
      " |  replace(...)\n",
      " |      S.replace(old, new[, count]) -> str\n",
      " |      \n",
      " |      Return a copy of S with all occurrences of substring\n",
      " |      old replaced by new.  If the optional argument count is\n",
      " |      given, only the first count occurrences are replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(...)\n",
      " |      S.rjust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S right-justified in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(...)\n",
      " |      S.rpartition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, starting at the end of S, and return\n",
      " |      the part before it, the separator itself, and the part after it.  If the\n",
      " |      separator is not found, return two empty strings and S.\n",
      " |  \n",
      " |  rsplit(...)\n",
      " |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string, starting at the end of the string and\n",
      " |      working to the front.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified, any whitespace string\n",
      " |      is a separator.\n",
      " |  \n",
      " |  rstrip(...)\n",
      " |      S.rstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with trailing whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(...)\n",
      " |      S.split(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified or is None, any\n",
      " |      whitespace string is a separator and empty strings are\n",
      " |      removed from the result.\n",
      " |  \n",
      " |  splitlines(...)\n",
      " |      S.splitlines([keepends]) -> list of strings\n",
      " |      \n",
      " |      Return a list of the lines in S, breaking at line boundaries.\n",
      " |      Line breaks are not included in the resulting list unless keepends\n",
      " |      is given and true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(...)\n",
      " |      S.strip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading and trailing\n",
      " |      whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(...)\n",
      " |      S.swapcase() -> str\n",
      " |      \n",
      " |      Return a copy of S with uppercase characters converted to lowercase\n",
      " |      and vice versa.\n",
      " |  \n",
      " |  title(...)\n",
      " |      S.title() -> str\n",
      " |      \n",
      " |      Return a titlecased version of S, i.e. words start with title case\n",
      " |      characters, all remaining cased characters have lower case.\n",
      " |  \n",
      " |  translate(...)\n",
      " |      S.translate(table) -> str\n",
      " |      \n",
      " |      Return a copy of the string S in which each character has been mapped\n",
      " |      through the given translation table. The table must implement\n",
      " |      lookup/indexing via __getitem__, for instance a dictionary or list,\n",
      " |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n",
      " |      this operation raises LookupError, the character is left untouched.\n",
      " |      Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(...)\n",
      " |      S.upper() -> str\n",
      " |      \n",
      " |      Return a copy of S converted to uppercase.\n",
      " |  \n",
      " |  zfill(...)\n",
      " |      S.zfill(width) -> str\n",
      " |      \n",
      " |      Pad a numeric string S with zeros on the left, to fill a field\n",
      " |      of the specified width. The string S is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd0d429",
   "metadata": {},
   "source": [
    "# RECURSION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04f0f57c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_positive_numbers(n):\n",
    "    sum=0\n",
    "    for i in range(1,n+1):# similar to 22nd cell\n",
    "        sum+=i\n",
    "    return sum\n",
    "            \n",
    "print(sum_positive_numbers(3))#input() function\n",
    "print(sum_positive_numbers(5))#input() function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb07ed2",
   "metadata": {},
   "source": [
    "# area of triangle "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d3d8f48f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter first side of triangle: 2\n",
      "enter second side of triangle: 3\n",
      "enter third side of triangle: 4\n",
      "perimeter of triangle = 4.5\n",
      "the area of triangle is  =  4.21875\n"
     ]
    }
   ],
   "source": [
    "a=float(input(\"enter first side of triangle: \"))\n",
    "b=float(input(\"enter second side of triangle: \"))\n",
    "c=float(input(\"enter third side of triangle: \"))\n",
    "#find perimeter of triangle\n",
    "s=(a+b+c)/2\n",
    "print('perimeter of triangle = ' + str(s))\n",
    "#find  area of triangle\n",
    "d=(s*(s-a)*(s-b)*(s-c))**1/2\n",
    "print('the area of triangle is  = ',d ) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cab90b58",
   "metadata": {},
   "source": [
    "# count the digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "548471f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ":45\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def count(number):\n",
    "    sum=0\n",
    "    #count=0\n",
    "    for i in str(number):\n",
    "        sum += int(i)\n",
    "        #count+=1\n",
    "    return sum #count   also using  how many digits\n",
    "print(count(input(\":\")))#1+2+3+4+5+6+7+8+9=45"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccc4da0e",
   "metadata": {},
   "source": [
    "# calculate the seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c0c5e0b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ";5000\n",
      "(1, 23, 20)\n"
     ]
    }
   ],
   "source": [
    "def time(seconds):\n",
    "    hours=seconds//3600\n",
    "    minutes=(seconds-hours*3600)//60\n",
    "    rem_second=seconds-(hours*3600)-(minutes*60)\n",
    "    return hours,minutes,rem_second\n",
    "print(time(int(input(\";\"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0429c06a",
   "metadata": {},
   "source": [
    "# dice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cd569154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0|0}{0|1}{0|2}{0|3}{0|4}{0|5}{0|6}\n",
      "{1|1}{1|2}{1|3}{1|4}{1|5}{1|6}\n",
      "{2|2}{2|3}{2|4}{2|5}{2|6}\n",
      "{3|3}{3|4}{3|5}{3|6}\n",
      "{4|4}{4|5}{4|6}\n",
      "{5|5}{5|6}\n",
      "{6|6}\n"
     ]
    }
   ],
   "source": [
    "for left in range(7):\n",
    "    for right in  range(left,7):\n",
    "        print('{'+str(left) + \"|\" + str(right) + \"}\",end=\"\")\n",
    "    print()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1e13818d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hellohello10\n"
     ]
    }
   ],
   "source": [
    "def counts(words):\n",
    "    final=words*2\n",
    "    finals=len(final)\n",
    "    return str(final) + str(finals)\n",
    "print(counts('hello'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a15751ed",
   "metadata": {},
   "source": [
    "# doubt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "609f29ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def  first_and_last(message):\n",
    "    first=message[0]\n",
    "    last=message[-1]\n",
    "    if first!=last:  \n",
    "        return False\n",
    "    return True\n",
    "print(first_and_last(\"else\"))\n",
    "print(first_and_last(\"tree\"))\n",
    "print(first_and_last(\"  \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "3f50d4f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USB\n",
      "LAN\n",
      "OS\n"
     ]
    }
   ],
   "source": [
    "def initials(phrase):\n",
    "    words = (phrase.upper()).split()\n",
    "    result = \"\"\n",
    "    for word in words:\n",
    "        result +=word[0]\n",
    "    return result\n",
    "\n",
    "print(initials(\"Universal Serial Bus\")) # Should be: USB\n",
    "print(initials(\"local area network\")) # Should be: LAN\n",
    "print(initials(\"Operating system\")) # Should be: OS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "f0a280d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qt\n"
     ]
    }
   ],
   "source": [
    "answers='ques tion'\n",
    "result=answer.split()\n",
    "print(result[0][0] + result[1][0])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59e6d113",
   "metadata": {},
   "source": [
    "# FORMATTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "6f3ee2d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter your name:dhananjezhian\n",
      "Hi dhananjezhian, your lucky numer is 39\n"
     ]
    }
   ],
   "source": [
    "name=str(input('enter your name:'))\n",
    "luck=len(name)*3\n",
    "print(\"Hi {}, your lucky numer is {}\".format(name ,luck))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "a02a8be2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct answers: 86.36%\n"
     ]
    }
   ],
   "source": [
    "points=19\n",
    "total=22\n",
    "print('Correct answers: {:.2%}'.format(points/total))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d55e160c",
   "metadata": {},
   "source": [
    "# reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ed25b35",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_palindrome(input_string):\n",
    "    new_string = input_string.replace(\" \",\"\").upper()\n",
    "    reverse_string = input_string.replace(\" \",\"\").upper()[::-1]\n",
    "    if  new_string==reverse_string:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "print(is_palindrome(\"Never Odd or Even\")) # Should be True\n",
    "print(is_palindrome(\"abc\")) # Should be False\n",
    "print(is_palindrome(\"kayak\")) # Should be True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0bb92064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's raining cats and dogs\n",
      "She sells seashells by the seashore\n",
      "The weather is nice in May\n",
      "The weather is nice in April\n"
     ]
    }
   ],
   "source": [
    "def replace_ending(sentence, old, new):\n",
    "\t# Check if the old string is at the end of the sentence \n",
    "\tif sentence.endswith(old):\n",
    "\t\t# Using i as the slicing index, combine the part\n",
    "\t\t# of the sentence up to the matched string at the \n",
    "\t\t# end with the new string\n",
    "\t\ti = sentence.rfind(old) #rindex(old) \n",
    "\t\tnew_sentence =sentence[:i]+new\n",
    "\t\treturn new_sentence\n",
    "\n",
    "\t# Return the original sentence if there is no match \n",
    "\treturn sentence\n",
    "\t\n",
    "print(replace_ending(\"It's raining cats and cats\", \"cats\", \"dogs\")) \n",
    "# Should display \"It's raining cats and dogs\"\n",
    "print(replace_ending(\"She sells seashells by the seashore\", \"seashells\", \"donuts\")) \n",
    "# Should display \"She sells seashells by the seashore\"\n",
    "print(replace_ending(\"The weather is nice in May\", \"may\", \"april\")) \n",
    "# Should display \"The weather is nice in May\"\n",
    "print(replace_ending(\"The weather is nice in May\", \"May\", \"April\")) \n",
    "# Should display \"The weather is nice in April\"\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ea1addc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nice\n"
     ]
    }
   ],
   "source": [
    "def word(seq,n):\n",
    "    words=seq.split()\n",
    "    if n<=len(words):\n",
    "        result=words[n-1]\n",
    "        return result\n",
    "    return 'none of the words!'\n",
    "print(word('The weather is nice in May',4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a2ed67b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'mango', 'banana', 'orange', 'pineapple']\n",
      "['goa', 'apple', 'mango', 'banana', 'orange', 'pineapple']\n"
     ]
    }
   ],
   "source": [
    "fruits=['apple','mango','banana','orange']\n",
    "fruits.append('pineapple')\n",
    "print(fruits)\n",
    "fruits.insert(0,'goa')\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2da5ac67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c', 'e', 'g']\n",
      "['Orange', 'Strawberry', 'Peach']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "def skip_elements(elements):\n",
    "    n=elements[0::2]\n",
    "    return n\n",
    "print(skip_elements([\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\"])) # Should be ['a', 'c', 'e', 'g']\n",
    "print(skip_elements(['Orange', 'Pineapple', 'Strawberry', 'Kiwi', 'Peach'])) # Should be ['Orange', 'Strawberry', 'Peach']\n",
    "print(skip_elements([])) # Should be []\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "fdbc6661",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0-a.\n",
      "1-b.\n",
      "2-c.\n",
      "3-d.\n",
      "4-e.\n",
      "5-f.\n",
      "6-g.\n"
     ]
    }
   ],
   "source": [
    "words=[\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\"]\n",
    "for i,m in enumerate(words):\n",
    "    print(\"{}-{}.\".format(i,m))\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c2e1fea",
   "metadata": {},
   "source": [
    "# multiple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "3d56ee25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 14, 21, 28, 35, 42, 49, 56, 63, 70]\n"
     ]
    }
   ],
   "source": [
    "n=[]\n",
    "for i in range(7,70+7,7):#(1,10)\n",
    "    n.append(i)#i*7\n",
    "print(n)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "2748ce54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 14, 21, 28, 35, 42, 49, 56, 63, 70]\n"
     ]
    }
   ],
   "source": [
    "m=[x for x in range(7,77,7)]#[x*7 for x in range(1,11)] ## no colon\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "347f103b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]\n"
     ]
    }
   ],
   "source": [
    "multiple=[i for i in range(1,100) if i %3==0]## no colon\n",
    "print(multiple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "078714a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 9, 10, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "fruits=['Orange', 'Pineapple', 'Strawberry', 'Kiwi', 'Peach']\n",
    "counts=[len(fruit) for fruit in fruits]\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "df6f745d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "num=['d','c','b','a']\n",
    "print(num.sort())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea8faf76",
   "metadata": {},
   "source": [
    "# questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "8e9f1e71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ollehay wohay eraay uoyay\n",
      "gnimmargorpay niay nohtypay siay nufay\n"
     ]
    }
   ],
   "source": [
    "def pig_latin(text):\n",
    "    say=[]\n",
    "    n=['ay']\n",
    "    word=text.split()\n",
    "    for i in word:\n",
    "        say.append(i[::-1])\n",
    "        now=\"ay \".join(say)\n",
    "    return now + 'ay'\n",
    "print(pig_latin(\"hello how are you \")) # Should be \"ellohay owhay reaay ouyay\"\n",
    "print(pig_latin(\"programming in python is fun\")) # Should be \"rogrammingpay niay ythonpay siay unfay\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "e1de9904",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ken is 30 years old and works as Chef\n",
      "Pat is 35 years old and works as Lawyer\n",
      "Amanda is 25 years old and works as Engineer\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nOutput should match:\\nKen is 30 years old and works as Chef\\nPat is 35 years old and works as Lawyer\\nAmanda is 25 years old and works as Engineer\\n'"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def guest_list(guests):\n",
    "\tfor name , age ,work in guests:\n",
    "        \n",
    "\t\tprint(\"{} is {} years old and works as {}\".format(name,age,work))\n",
    "\n",
    "guest_list([('Ken', 30, \"Chef\"), (\"Pat\", 35, 'Lawyer'), ('Amanda', 25, \"Engineer\")])\n",
    "\n",
    "#Click Run to submit code\n",
    "\"\"\"\n",
    "Output should match:\n",
    "Ken is 30 years old and works as Chef\n",
    "Pat is 35 years old and works as Lawyer\n",
    "Amanda is 25 years old and works as Engineer\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "c24b0875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "program.c stdio.h sample.h a.out math.h hpp.out\n"
     ]
    }
   ],
   "source": [
    "filenames = [\"program.c\", \"stdio.hpp\", \"sample.hpp\", \"a.out\", \"math.hpp\", \"hpp.out\"]\n",
    "# Generate newfilenames as a list containing the new filenames\n",
    "# using as many lines of code as your chosen method requires.\n",
    "old=\" \".join(filenames)\n",
    "new=old.replace(\".hpp\",'.h')\n",
    "\n",
    "print(new) \n",
    "# Should be [\"program.c\", \"stdio.h\", \"sample.h\", \"a.out\", \"math.h\", \"hpp.out\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "b52d3c2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Marketing: Mike, Karen, Jake, Tasha\n",
      "Engineering: Kim, Jay, Tom\n",
      "Users: \n"
     ]
    }
   ],
   "source": [
    "def group_list(group, users):\n",
    "  members = []\n",
    "  members=\", \".join(users)\n",
    "  return \"{}: {}\".format(group ,members)\n",
    "\n",
    "print(group_list(\"Marketing\", [\"Mike\", \"Karen\", \"Jake\", \"Tasha\"])) # Should be \"Marketing: Mike, Karen, Jake, Tasha\"\n",
    "print(group_list(\"Engineering\", [\"Kim\", \"Jay\", \"Tom\"])) # Should be \"Engineering: Kim, Jay, Tom\"\n",
    "print(group_list(\"Users\", \"\")) # Should be \"Users:\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2a778253",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rwxr-xr-x\n",
      "rw-r--r--\n",
      "rwxr-x---\n",
      "rw-------\n"
     ]
    }
   ],
   "source": [
    "def octal_to_string(octal):\n",
    "    result = \"\"\n",
    "    value_letters = [(4,\"r\"),(2,\"w\"),(1,\"x\")]\n",
    "    # Iterate over each of the digits in octal\n",
    "    for digit in [int(n) for n in str(octal)]:\n",
    "        # Check for each of the permissions values\n",
    "        for value, letter in value_letters:\n",
    "            if digit >= value:\n",
    "                result += letter\n",
    "                digit -= value\n",
    "            else:\n",
    "                result+='-'\n",
    "    return result\n",
    "    \n",
    "print(octal_to_string(755)) # Should be rwxr-xr-x\n",
    "print(octal_to_string(644)) # Should be rw-r--r--\n",
    "print(octal_to_string(750)) # Should be rwxr-x---\n",
    "print(octal_to_string(600)) # Should be rw-------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1c4e46ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('octopuses', 'tentacles'), ('dolphins', 'fins'), ('rhinos', 'horns')])\n"
     ]
    }
   ],
   "source": [
    "cool_beasts = {\"octopuses\":\"tentacles\", \"dolphins\":\"fins\", \"rhinos\":\"horns\"}\n",
    "print(cool_beasts.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "247a340f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "octopuses have tentacles\n",
      "dolphins have fins\n",
      "rhinos have horns\n"
     ]
    }
   ],
   "source": [
    "cool_beasts = {\"octopuses\":\"tentacles\", \"dolphins\":\"fins\", \"rhinos\":\"horns\"}\n",
    "for keys, values in cool_beasts.items():\n",
    "    print(\"{} have {}\".format(keys,values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "bd6b41a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DHANANJEZHIAN\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'D': 1, 'H': 2, 'A': 3, 'N': 3, 'J': 1, 'E': 1, 'Z': 1, 'I': 1}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count(text):\n",
    "    words={}\n",
    "    for letters in text:\n",
    "        if letters not in words:\n",
    "            words[letters]=0\n",
    "        words[letters]+=1\n",
    "    return words\n",
    "count(str(input()))\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "21a05830",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red shirt\n",
      "blue shirt\n",
      "white shirt\n",
      "blue jeans\n",
      "black jeans\n"
     ]
    }
   ],
   "source": [
    "wardrobe = {\"shirt\":[\"red\",\"blue\",\"white\"], \"jeans\":[\"blue\",\"black\"]}\n",
    "for keys , values in wardrobe.items():\n",
    "    for value in values:\n",
    "        print(\"{} {}\".format(value ,keys))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "48fbfadc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['clark.kent@gmail.com', 'diana.prince@gmail.com', 'peter.parker@gmail.com', 'barbara.gordon@yahoo.com', 'jean.grey@yahoo.com', 'bruce.wayne@hotmail.com']\n"
     ]
    }
   ],
   "source": [
    "def email_list(domains):\n",
    "    new=[]\n",
    "    for keys,values in domains.items():\n",
    "        for value in values:\n",
    "            new.append(\"{}{}{}\".format(value ,'@',keys))\n",
    "    return new\n",
    "\n",
    "print(email_list({\"gmail.com\": [\"clark.kent\", \"diana.prince\", \"peter.parker\"], \"yahoo.com\": [\"barbara.gordon\", \"jean.grey\"], \"hotmail.com\": [\"bruce.wayne\"]}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "e9bf6ce9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'admin': ['local', 'public', 'administrator'], 'userA': ['local'], 'userB': ['public']}\n"
     ]
    }
   ],
   "source": [
    "def groups_per_user(group_dictionary):\n",
    "    user_groups = {}\n",
    "    # Go through group_dictionary\n",
    "    for keys, values in group_dictionary.items():\n",
    "        # Now go through the users in the grou\n",
    "        for value in values:\n",
    "            user_groups[value] =user_groups.get(value,[])+[keys]\n",
    "\n",
    "    return(user_groups)\n",
    "\n",
    "print(groups_per_user({\"local\": [\"admin\", \"userA\"],\n",
    "         \"public\":  [\"admin\", \"userB\"],\n",
    "         \"administrator\": [\"admin\"] }))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "a740fedb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have a NICE day\n",
      "Shhh, don't be so LOUD!\n",
      "Automating with Python is FUN\n"
     ]
    }
   ],
   "source": [
    "def highlight_word(sentence, word):\n",
    "    return sentence.replace(word,word.upper())\n",
    "\n",
    "print(highlight_word(\"Have a nice day\", \"nice\"))\n",
    "print(highlight_word(\"Shhh, don't be so loud!\", \"loud\"))\n",
    "print(highlight_word(\"Automating with Python is fun\", \"fun\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "354b0a3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mike', 'Carol', 'Greg', 'Marcia', 'Peter', 'Jan', 'Bobby', 'Cindy', 'Alice']\n"
     ]
    }
   ],
   "source": [
    "def combine_lists(list1, list2):\n",
    "    return  list2 + list1[::-1] \n",
    "Jamies_list = [\"Alice\", \"Cindy\", \"Bobby\", \"Jan\", \"Peter\"]\n",
    "Drews_list = [\"Mike\", \"Carol\", \"Greg\", \"Marcia\"]\n",
    "\n",
    "print(combine_lists(Jamies_list, Drews_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "71286158",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9]\n",
      "[1, 4, 9, 16, 25]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "def squares(start, end):\n",
    "    num=[]\n",
    "    for i in range(start,end+1):\n",
    "        num.append(i*i)\n",
    "    return num\n",
    "        \n",
    "    \n",
    "\n",
    "print(squares(2, 3)) # Should be [4, 9]\n",
    "print(squares(1, 5)) # Should be [1, 4, 9, 16, 25]\n",
    "print(squares(0, 10)) # Should be [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "a3f24d2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kia Soul costs 19000 dollars\n",
      "Lamborghini Diablo costs 55000 dollars\n",
      "Ford Fiesta costs 13000 dollars\n",
      "Toyota Prius costs 24000 dollars\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def car_listing(car_prices):\n",
    "  result = \"\"\n",
    "  for keys, values in car_prices.items():\n",
    "    result +=\"{} costs {} dollars\".format(keys ,values) + \"\\n\"\n",
    "  return  result \n",
    "\n",
    "print(car_listing({\"Kia Soul\":19000, \"Lamborghini Diablo\":55000, \"Ford Fiesta\":13000, \"Toyota Prius\":24000}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "8ac0312a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pop\n",
      "t\n",
      "us\n",
      "['red', 'white', 'yellow', 'blue']\n",
      "dict_keys(['router', 'localhost', 'google'])\n"
     ]
    }
   ],
   "source": [
    "animal = \"Hippopotamus\"\n",
    "print(animal[3:6])\n",
    "print(animal[-5])\n",
    "print(animal[10:])\n",
    "colors = [\"red\", \"white\", \"blue\"]\n",
    "colors.insert(2, \"yellow\")\n",
    "print(colors)\n",
    "host_addresses = {\"router\": \"192.168.1.1\", \"localhost\": \"127.0.0.1\", \"google\": \"8.8.8.8\"}\n",
    "print(host_addresses.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "b20061e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "house number 123 on street named Main Street\n",
      "house number 1001 on street named 1st Ave\n",
      "house number 55 on street named North Center Drive\n"
     ]
    }
   ],
   "source": [
    "def format_address(address_string):\n",
    "    var = address_string.split()\n",
    "    results=\"house number {} on street named {}\".format(var[0], \" \".join(var[1:]))\n",
    "    return results\n",
    "\n",
    "print(format_address(\"123 Main Street\"))\n",
    "# Should print: \"house number 123 on street named Main Street\"\n",
    "\n",
    "print(format_address(\"1001 1st Ave\"))\n",
    "# Should print: \"house number 1001 on street named 1st Ave\"\n",
    "\n",
    "print(format_address(\"55 North Center Drive\"))\n",
    "# Should print \"house number 55 on street named North Center Drive\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f6e4b711",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 2, 'b': 2, 'c': 2}\n",
      "{'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\n",
      "{'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}\n"
     ]
    }
   ],
   "source": [
    "def count_letters(text):\n",
    "  result = {}\n",
    "  # Go through each letter in the text\n",
    "  convert_text = text.lower()\n",
    "\n",
    "  for letter in convert_text:\n",
    "    if letter.isalpha():\n",
    "      if letter in result:\n",
    "        result[letter] += 1\n",
    "      else:\n",
    "        result[letter] = 1\n",
    "\n",
    "  return result\n",
    "    \n",
    "print(count_letters(\"AaBbCc\"))\n",
    "# Should be {'a': 2, 'b': 2, 'c': 2}\n",
    "\n",
    "print(count_letters(\"Math is fun! 2+2=4\"))\n",
    "# Should be {'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\n",
    "\n",
    "print(count_letters(\"This is a sentence.\"))\n",
    "# Should be {'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81627cb5",
   "metadata": {},
   "source": [
    "# print words in line with num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "755515e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-DHANANJEZHIAN\n",
      "2-dj\n",
      "3-vicky\n"
     ]
    }
   ],
   "source": [
    "words= ['DHANANJEZHIAN','dj','vicky']#\"DHANANJEZHIAN\"\n",
    "for i,letters in enumerate(words):\n",
    "    print(\"{}-{}\".format(i+1,letters))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdd4ead",
   "metadata": {},
   "source": [
    "# week 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "27a508d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SWEET\n",
      "CREAM\n"
     ]
    }
   ],
   "source": [
    "class Apple:\n",
    "    color=''\n",
    "    flavour=''\n",
    "opens=Apple()\n",
    "opens.color='red'\n",
    "opens.flavour='sweet'\n",
    "print(opens.flavour.upper())\n",
    "close=Apple()\n",
    "close.color='yellow'\n",
    "close.flavour='cream'\n",
    "print(close.flavour.upper())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "0bdd7d5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Johanna has 2 apples and Martin has 1 apples\n",
      "Johanna has 2 ideas and Martin has 2 ideas\n"
     ]
    }
   ],
   "source": [
    "# “If you have an apple and I have an apple and we exchange these apples then\n",
    "# you and I will still each have one apple. But if you have an idea and I have\n",
    "# an idea and we exchange these ideas, then each of us will have two ideas.”\n",
    "# George Bernard Shaw\n",
    "\n",
    "class Person:\n",
    "    apples = 0\n",
    "    ideas = 0\n",
    "\n",
    "johanna = Person()\n",
    "johanna.apples = 1\n",
    "johanna.ideas = 1\n",
    "\n",
    "martin = Person()\n",
    "martin.apples = 2\n",
    "martin.ideas = 1\n",
    "\n",
    "def exchange_apples(you, me):\n",
    "#Here, despite G.B. Shaw's quote, our characters have started with       #different amounts of apples so we can better observe the results. \n",
    "#We're going to have Martin and Johanna exchange ALL their apples with #one another.\n",
    "#Hint: how would you switch values of variables, \n",
    "#so that \"you\" and \"me\" will exchange ALL their apples with one another?\n",
    "#Do you need a temporary variable to store one of the values?\n",
    "#You may need more than one line of code to do that, which is OK. \n",
    "    temp = you.apples\n",
    "    you.apples = me.apples\n",
    "    me.apples = temp\n",
    "    return you.apples, me.apples\n",
    "    \n",
    "def exchange_ideas(you, me):\n",
    "    #\"you\" and \"me\" will share our ideas with one another.\n",
    "    #What operations need to be performed, so that each object receives\n",
    "    #the shared number of ideas?\n",
    "    #Hint: how would you assign the total number of ideas to \n",
    "    #each idea attribute? Do you need a temporary variable to store \n",
    "    #the sum of ideas, or can you find another way? \n",
    "    #Use as many lines of code as you need here.\n",
    "    temp = you.ideas\n",
    "    you.ideas += me.ideas\n",
    "    me.ideas += temp\n",
    "    return you.ideas, me.ideas\n",
    "\n",
    "exchange_apples(johanna, martin)\n",
    "print(\"Johanna has {} apples and Martin has {} apples\".format(johanna.apples, martin.apples))\n",
    "exchange_ideas(johanna, martin)\n",
    "print(\"Johanna has {} ideas and Martin has {} ideas\".format(johanna.ideas, martin.ideas))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "653b1545",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cusco, Peru\n",
      "Sofia, Bulgaria\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# define a basic city class\n",
    "class City:\n",
    "\tname = \"\"\n",
    "\tcountry = \"\"\n",
    "\televation = 0 \n",
    "\tpopulation = 0\n",
    "\n",
    "# create a new instance of the City class and\n",
    "# define each attribute\n",
    "city1 = City()\n",
    "city1.name = \"Cusco\"\n",
    "city1.country = \"Peru\"\n",
    "city1.elevation = 3399\n",
    "city1.population = 358052\n",
    "\n",
    "# create a new instance of the City class and\n",
    "# define each attribute\n",
    "city2 = City()\n",
    "city2.name = \"Sofia\"\n",
    "city2.country = \"Bulgaria\"\n",
    "city2.elevation = 2290\n",
    "city2.population = 1241675\n",
    "\n",
    "# create a new instance of the City class and\n",
    "# define each attribute\n",
    "city3 = City()\n",
    "city3.name = \"Seoul\"\n",
    "city3.country = \"South Korea\"\n",
    "city3.elevation = 38\n",
    "city3.population = 9733509\n",
    "\n",
    "def max_elevation_city(min_population):\n",
    "\t# Initialize the variable that will hold \n",
    "# the information of the city with \n",
    "# the highest elevation \n",
    "\treturn_city = City()\n",
    "\n",
    "\t# Evaluate the 1st instance to meet the requirements:\n",
    "\t# does city #1 have at least min_population and\n",
    "\t# is its elevation the highest evaluated so far?\n",
    "\tif (city1.population > min_population):\n",
    "\t\treturn   \"{}, {}\".format(city1.name, city1.country)\n",
    "\t# Evaluate the 2nd instance to meet the requirements:\n",
    "\t# does city #2 have at least min_population and\n",
    "\t# is its elevation the highest evaluated so far?\n",
    "\tif (city2.population > min_population):\n",
    "\t\treturn  \"{}, {}\".format(city2.name, city2.country)\n",
    "\t# Evaluate the 3rd instance to meet the requirements:\n",
    "\t# does city #3 have at least min_population and\n",
    "\t# is its elevation the highest evaluated so far?\n",
    "\tif (city3.population > min_population):\n",
    "\t\treturn \"{}, {}\".format(city3.name, city3.country)\n",
    "\telse:\n",
    "         return \"\"\n",
    "\n",
    "print(max_elevation_city(100000)) # Should print \"Cusco, Peru\"\n",
    "print(max_elevation_city(1000000)) # Should print \"Sofia, Bulgaria\"\n",
    "print(max_elevation_city(10000000)) # Should print \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f09e81f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oink oink\n"
     ]
    }
   ],
   "source": [
    "class piglet:\n",
    "    def animal(self):\n",
    "        print(\"oink oink\")\n",
    "speak=piglet()\n",
    "speak.animal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "38a88a63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pig sound is oink\n",
      "Pig sound is oink oink\n"
     ]
    }
   ],
   "source": [
    "class animal:\n",
    "    def pig(self):\n",
    "        print(\"Pig sound is {}\".format(self.name))\n",
    "wild=animal()\n",
    "wild.name='oink'\n",
    "wild.pig()\n",
    "domestic=animal()\n",
    "domestic.name='oink oink'\n",
    "domestic.pig()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "653741cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "class piglet:\n",
    "    year=0\n",
    "    def pig(self):\n",
    "        print(self.year*18)\n",
    "try1=piglet()\n",
    "try1.pig()\n",
    "\n",
    "try2=piglet()\n",
    "try2.year=2\n",
    "try2.pig()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b28e631d",
   "metadata": {},
   "source": [
    "# special method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ab22ac5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'red'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class animal:\n",
    "    def __init__(self,color,flavour):\n",
    "        self.color=color\n",
    "        self.flavour=flavour\n",
    "try1=animal(\"red\",\"cream\")\n",
    "try1.color\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e11de57d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, my name is dhananjezhian\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name):\n",
    "        self.name=name\n",
    "    def greeting(self):\n",
    "        return \"hi, my name is {}\".format(self.name)\n",
    "some_name=Person(\"dhananjezhian\")\n",
    "print(some_name.greeting())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9e3351cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The color is pink and The  Flavour is cream\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,color,flavour):\n",
    "        self.color=color\n",
    "        self.flavour=flavour\n",
    "    def __str__(self):\n",
    "        return \"The color is {} and The  Flavour is {}\".format(self.color,self.flavour)\n",
    "try1=Person(\"pink\",'cream')\n",
    "print(try1)      "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b1ed8b2",
   "metadata": {},
   "source": [
    "# doc_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "89a95d63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Apple in module __main__:\n",
      "\n",
      "class Apple(builtins.object)\n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, color, flavor)\n",
      " |      initilize the self\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      return tha colour and flavour of the object\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Apple:\n",
    "     def __init__(self, color, flavor):\n",
    "         \"\"\"initilize the self \"\"\"   \n",
    "         self.color = color\n",
    "         self.flavor = flavor\n",
    "     def __str__(self):\n",
    "        \"\"\"return tha colour and flavour of the object \"\"\"\n",
    "        return \"This apple is {} and its flavor is {}\".format(self.color, self.flavor)\n",
    " \n",
    "help(Apple)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}